Merge pull request #259 from BastiaanOlij/update_3.1_stable

Synced with Godot 3.1 stable

.clang-format

@@ -0,0 +1,126 @@
+# Commented out parameters are those with the same value as base LLVM style
+# We can uncomment them if we want to change their value, or enforce the
+# chosen value in case the base style changes (last sync: Clang 6.0.1).
+---
+### General config, applies to all languages ###
+BasedOnStyle:  LLVM
+AccessModifierOffset: -4
+AlignAfterOpenBracket: DontAlign
+# AlignConsecutiveAssignments: false
+# AlignConsecutiveDeclarations: false
+# AlignEscapedNewlines: Right
+# AlignOperands:   true
+AlignTrailingComments: false
+AllowAllParametersOfDeclarationOnNextLine: false
+# AllowShortBlocksOnASingleLine: false
+AllowShortCaseLabelsOnASingleLine: true
+AllowShortFunctionsOnASingleLine: Inline
+AllowShortIfStatementsOnASingleLine: true
+# AllowShortLoopsOnASingleLine: false
+# AlwaysBreakAfterDefinitionReturnType: None
+# AlwaysBreakAfterReturnType: None
+# AlwaysBreakBeforeMultilineStrings: false
+# AlwaysBreakTemplateDeclarations: false
+# BinPackArguments: true
+# BinPackParameters: true
+# BraceWrapping:
+#   AfterClass:      false
+#   AfterControlStatement: false
+#   AfterEnum:       false
+#   AfterFunction:   false
+#   AfterNamespace:  false
+#   AfterObjCDeclaration: false
+#   AfterStruct:     false
+#   AfterUnion:      false
+#   AfterExternBlock: false
+#   BeforeCatch:     false
+#   BeforeElse:      false
+#   IndentBraces:    false
+#   SplitEmptyFunction: true
+#   SplitEmptyRecord: true
+#   SplitEmptyNamespace: true
+# BreakBeforeBinaryOperators: None
+# BreakBeforeBraces: Attach
+# BreakBeforeInheritanceComma: false
+BreakBeforeTernaryOperators: false
+# BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: AfterColon
+# BreakStringLiterals: true
+ColumnLimit:     0
+# CommentPragmas:  '^ IWYU pragma:'
+# CompactNamespaces: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+ConstructorInitializerIndentWidth: 8
+ContinuationIndentWidth: 8
+Cpp11BracedListStyle: false
+# DerivePointerAlignment: false
+# DisableFormat:   false
+# ExperimentalAutoDetectBinPacking: false
+# FixNamespaceComments: true
+# ForEachMacros:
+#   - foreach
+#   - Q_FOREACH
+#   - BOOST_FOREACH
+# IncludeBlocks:   Preserve
+IncludeCategories:
+  - Regex:           '".*"'
+    Priority:        1
+  - Regex:           '^<.*\.h>'
+    Priority:        2
+  - Regex:           '^<.*'
+    Priority:        3
+# IncludeIsMainRegex: '(Test)?$'
+IndentCaseLabels: true
+# IndentPPDirectives: None
+IndentWidth:     4
+# IndentWrappedFunctionNames: false
+# JavaScriptQuotes: Leave
+# JavaScriptWrapImports: true
+# KeepEmptyLinesAtTheStartOfBlocks: true
+# MacroBlockBegin: ''
+# MacroBlockEnd:   ''
+# MaxEmptyLinesToKeep: 1
+# NamespaceIndentation: None
+# PenaltyBreakAssignment: 2
+# PenaltyBreakBeforeFirstCallParameter: 19
+# PenaltyBreakComment: 300
+# PenaltyBreakFirstLessLess: 120
+# PenaltyBreakString: 1000
+# PenaltyExcessCharacter: 1000000
+# PenaltyReturnTypeOnItsOwnLine: 60
+# PointerAlignment: Right
+# RawStringFormats:
+#   - Delimiter:       pb
+#     Language:        TextProto
+#     BasedOnStyle:    google
+# ReflowComments:  true
+# SortIncludes:    true
+# SortUsingDeclarations: true
+# SpaceAfterCStyleCast: false
+# SpaceAfterTemplateKeyword: true
+# SpaceBeforeAssignmentOperators: true
+# SpaceBeforeParens: ControlStatements
+# SpaceInEmptyParentheses: false
+# SpacesBeforeTrailingComments: 1
+# SpacesInAngles:  false
+# SpacesInContainerLiterals: true
+# SpacesInCStyleCastParentheses: false
+# SpacesInParentheses: false
+# SpacesInSquareBrackets: false
+TabWidth:        4
+UseTab:          Always
+---
+### C++ specific config ###
+Language:        Cpp
+Standard:        Cpp03
+---
+### ObjC specific config ###
+Language:        ObjC
+ObjCBlockIndentWidth: 4
+# ObjCSpaceAfterProperty: false
+# ObjCSpaceBeforeProtocolList: true
+---
+### Java specific config ###
+Language:        Java
+# BreakAfterJavaFieldAnnotations: false
+...

.gitignore

@@ -1,8 +1,3 @@
-# Generated bindings
-src/*.cpp
-src/*.hpp
-include/*.hpp
-
 # Misc
 logs/*
 
@@ -16,3 +11,8 @@ logs/*
 *.pdb
 *.lib
 bin
+*.config
+*.creator
+*.creator.user
+*.files
+*.includes

CMakeLists.txt

@@ -0,0 +1,181 @@
+# cmake arguments
+# CMAKE_BUILD_TYPE:			Compilation target (Debug or Release defaults to Debug)
+# 
+# godot-cpp cmake arguments
+# GODOT_HEADERS_DIR:		This is where the gdnative include folder is (godot_source/modules/gdnative/include)
+# GODOT_CUSTOM_API_FILE:	This is if you have another path for the godot_api.json
+# 
+# Android cmake arguments
+# CMAKE_TOOLCHAIN_FILE:		The path to the android cmake toolchain ($ANDROID_NDK/build/cmake/android.toolchain.cmake)
+# ANDROID_NDK:				The path to the android ndk root folder
+# ANDROID_TOOLCHAIN_NAME:	The android toolchain (arm-linux-androideabi-4.9 or aarch64-linux-android-4.9 or x86-4.9 or x86_64-4.9)
+# ANDROID_PLATFORM:			The android platform version (android-23)
+# More info here: https://godot.readthedocs.io/en/latest/development/compiling/compiling_for_android.html
+# 
+# Examples
+# 
+# Builds a debug version:
+# cmake .
+# cmake --build .
+# 
+# Builds a release version with clang
+# CC=/usr/bin/clang CXX=/usr/bin/clang++ cmake -DCMAKE_BUILD_TYPE=Release -G "Unix Makefiles" .
+# cmake --build .
+# 
+# Builds an android armeabi-v7a debug version:
+# cmake -DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK/build/cmake/android.toolchain.cmake -DANDROID_NDK=$ANDROID_NDK \
+#		-DANDROID_TOOLCHAIN_NAME=arm-linux-androideabi-4.9 -DANDROID_PLATFORM=android-23 -DCMAKE_BUILD_TYPE=Debug .
+# cmake --build .
+# 
+# Protip
+# Generate the buildfiles in a sub directory to not clutter the root directory with build files:
+# mkdir build && cd build && cmake -G "Unix Makefiles" .. && cmake --build .
+# 
+# Todo
+# Test build for Windows, Mac and mingw.
+
+project(godot-cpp)
+cmake_minimum_required(VERSION 3.6)
+
+# Change the output directory to the bin directory
+set(BUILD_PATH ${CMAKE_SOURCE_DIR}/bin)
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${BUILD_PATH}")
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${BUILD_PATH}")
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${BUILD_PATH}")
+SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY_DEBUG "${BUILD_PATH}")
+SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY_RELEASE "${BUILD_PATH}")
+SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG "${BUILD_PATH}")
+SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE "${BUILD_PATH}")
+SET(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_DEBUG "${BUILD_PATH}")
+SET(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELEASE "${BUILD_PATH}")
+
+# Default build type is Debug in the SConstruct
+if(CMAKE_BUILD_TYPE STREQUAL "")
+	set(CMAKE_BUILD_TYPE Debug)
+endif()
+
+if(CMAKE_BUILD_TYPE MATCHES Debug)
+	add_definitions(-D_DEBUG)
+else()
+	add_definitions(-DNDEBUG)
+endif(CMAKE_BUILD_TYPE MATCHES Debug)
+
+# Set the c++ standard to c++14
+set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+# Input from user for godot headers and the api file
+set(GODOT_HEADERS_DIR "godot_headers" CACHE STRING "")
+set(GODOT_CUSTOM_API_FILE "godot_headers/api.json" CACHE STRING "")
+
+set(GODOT_COMPILE_FLAGS )
+set(GODOT_LINKER_FLAGS )
+
+if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "MSVC")
+	# using Visual Studio C++
+	set(GODOT_COMPILE_FLAGS "/EHsc /WX") # /GF /MP
+
+	if(CMAKE_BUILD_TYPE MATCHES Debug)
+		set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} /MDd") # /Od /RTC1 /Zi
+	else()
+		set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} /MD /O2") # /Oy /GL /Gy
+		STRING(REGEX REPLACE "/RTC(su|[1su])" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+		string(REPLACE "/RTC1" "" CMAKE_CXX_FLAGS_DEBUG ${CMAKE_CXX_FLAGS_DEBUG})
+	endif(CMAKE_BUILD_TYPE MATCHES Debug)
+
+	# Disable conversion warning, trunkation, unreferenced var, signed missmatch
+	set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} /wd4244 /wd4305 /wd4101 /wd4018 /wd4267")
+
+	# Todo: Check if needed.
+	add_definitions(-DWIN32_LEAN_AND_MEAN -D_CRT_SECURE_NO_WARNINGS)
+
+	# Unkomment for warning level 4
+	#if(CMAKE_CXX_FLAGS MATCHES "/W[0-4]")
+	#	string(REGEX REPLACE "/W[0-4]" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+	#endif()
+
+else()
+
+#elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
+	# using Clang
+#elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+	# using GCC and maybe MinGW?
+
+	set(GODOT_LINKER_FLAGS "-static-libgcc -static-libstdc++ -Wl,-R,'$$ORIGIN'")
+
+	# Hmm.. maybe to strikt?
+	set(GODOT_COMPILE_FLAGS "-fPIC -g -Wwrite-strings")
+	set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} -Wchar-subscripts -Wcomment -Wdisabled-optimization")
+	set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} -Wformat -Wformat=2 -Wformat-security -Wformat-y2k")
+	set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} -Wimport -Winit-self -Winline -Winvalid-pch -Werror")
+	set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} -Wlong-long -Wmissing-braces -Wmissing-format-attribute")
+	set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} -Wmissing-include-dirs -Wmissing-noreturn -Wpacked -Wpointer-arith")
+	set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} -Wredundant-decls -Wreturn-type -Wsequence-point")
+	set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} -Wswitch -Wswitch-enum -Wtrigraphs")
+	set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} -Wuninitialized -Wunknown-pragmas -Wunreachable-code -Wunused-label")
+	set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} -Wunused-value -Wvariadic-macros -Wvolatile-register-var -Wno-error=attributes")
+
+	# -Wshadow -Wextra -Wall -Weffc++ -Wfloat-equal -Wstack-protector -Wunused-parameter -Wsign-compare -Wunused-variable -Wcast-align
+	# -Wunused-function -Wstrict-aliasing -Wstrict-aliasing=2 -Wmissing-field-initializers
+
+	if(NOT CMAKE_SYSTEM_NAME STREQUAL "Android")
+		set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} -Wno-ignored-attributes")
+	endif()
+
+	if(CMAKE_BUILD_TYPE MATCHES Debug)
+		set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} -fno-omit-frame-pointer -O0")
+	else()
+		set(GODOT_COMPILE_FLAGS "${GODOT_COMPILE_FLAGS} -O3")
+	endif(CMAKE_BUILD_TYPE MATCHES Debug)
+endif()
+
+# Generate source from the bindings file
+message(STATUS "Generating Bindings")
+execute_process(COMMAND "python" "-c" "import binding_generator; binding_generator.generate_bindings(\"${GODOT_CUSTOM_API_FILE}\")"
+	WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+	RESULT_VARIABLE GENERATION_RESULT
+	OUTPUT_VARIABLE GENERATION_OUTPUT)
+message(STATUS ${GENERATION_RESULT} ${GENERATION_OUTPUT})
+
+# Get Sources
+file(GLOB_RECURSE SOURCES src/*.c**)
+file(GLOB_RECURSE HEADERS include/*.h**)
+
+# Define our godot-cpp library
+add_library(${PROJECT_NAME} ${SOURCES} ${HEADERS})
+target_include_directories(${PROJECT_NAME}
+	PRIVATE
+	include
+	include/core
+	include/gen
+)
+
+# Put godot headers as SYSTEM PUBLIC to exclude warnings from irrelevant headers
+target_include_directories(${PROJECT_NAME}
+	SYSTEM PUBLIC
+	${GODOT_HEADERS_DIR}
+)
+
+# Add the compile flags
+set_property(TARGET ${PROJECT_NAME} APPEND_STRING PROPERTY COMPILE_FLAGS ${GODOT_COMPILE_FLAGS})
+set_property(TARGET ${PROJECT_NAME} APPEND_STRING PROPERTY LINK_FLAGS ${GODOT_LINKER_FLAGS})
+
+# Create the correct name (godot.os.build_type.system_bits)
+
+set(BITS 32)
+if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+	set(BITS 64)
+endif(CMAKE_SIZEOF_VOID_P EQUAL 8)
+
+string(TOLOWER ${CMAKE_SYSTEM_NAME} SYSTEM_NAME)
+string(TOLOWER ${CMAKE_BUILD_TYPE} BUILD_TYPE)
+
+if(ANDROID)
+	# Added the android abi after system name
+	set(SYSTEM_NAME ${SYSTEM_NAME}.${ANDROID_ABI})
+	# Android does not have the bits at the end if you look at the main godot repo build
+	set_property(TARGET ${PROJECT_NAME} PROPERTY OUTPUT_NAME "godot-cpp.${SYSTEM_NAME}.${BUILD_TYPE}")
+else()
+	set_property(TARGET ${PROJECT_NAME} PROPERTY OUTPUT_NAME "godot-cpp.${SYSTEM_NAME}.${BUILD_TYPE}.${BITS}")
+endif()

LICENSE.md

@@ -1,6 +1,6 @@
-MIT License
+# MIT License
 
-Copyright (c) 2017 GodotNativeTools
+Copyright (c) 2017-2019 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

Makefile

@@ -1,13 +1,12 @@
 GENERATE_BINDINGS = no
 HEADERS = godot_headers
 TARGET = debug
-NAME = godot-cpp
 USE_CLANG = no
 
-BASE = scons n=$(NAME) use_llvm=$(USE_CLANG) generate_bindings=$(GENERATE_BINDINGS) target=$(TARGET) headers=$(HEADERS) -j4
-LINUX = $(BASE) p=linux
-WINDOWS = $(BASE) p=windows
-OSX = $(BASE) p=osx
+BASE = scons use_llvm=$(USE_CLANG) generate_bindings=$(GENERATE_BINDINGS) target=$(TARGET) headers=$(HEADERS) -j4
+LINUX = $(BASE) platform=linux
+WINDOWS = $(BASE) platform=windows
+OSX = $(BASE) platform=osx
 
 
 all:
@@ -20,10 +19,10 @@ linux:
 	make linux64
 
 linux32: SConstruct
-	$(LINUX) a=32
+	$(LINUX) bits=32
 
 linux64: SConstruct
-	$(LINUX) a=64
+	$(LINUX) bits=64
 
 
 windows:
@@ -31,10 +30,10 @@ windows:
 	make windows64
 
 windows32: SConstruct
-	$(WINDOWS) a=32
+	$(WINDOWS) bits=32
 
 windows64: SConstruct
-	$(WINDOWS) a=64
+	$(WINDOWS) bits=64
 
 
 osx:
@@ -42,7 +41,7 @@ osx:
 	make osx64
 
 osx32: SConstruct
-	$(OSX) a=32
+	$(OSX) bits=32
 
 osx64: SConstruct
-	$(OSX) a=64
+	$(OSX) bits=64

README.md

@@ -1,123 +1,198 @@
 # godot-cpp
 C++ bindings for the Godot script API
 
-# Creating a GDNative library (Linux)
-Create a directory named `SimpleLibrary` with subdirectories `lib, src`
+The instructions below feature the new NativeScript 1.1 class structure and will only work for modules created for Godot 3.1 and later. Use the following branches for older implementations:
+
+Version | Branch
+--- | ---
+**Godot 3.0 Nativescript 1.0** | [3.0](https://github.com/GodotNativeTools/godot-cpp/tree/3.0)
+**Godot 3.1 Nativescript 1.0** | [nativescript-1.0](https://github.com/GodotNativeTools/godot-cpp/tree/nativescript-1.0)
+
+Index:
+-   [**Contributing**](#contributing)
+-   [**Getting Started**](#getting-started)
+-   [**Creating a simple class**](#creating-a-simple-class)
+
+## Contributing
+We greatly appreciate help in maintaining and extending this project. 
+If you wish to help out ensure you have an account on Github and create a "fork" of the this repo.
+Rémi "Akien" Verschelde wrote an excellent bit of documentation for the main Godot project on this: 
+https://docs.godotengine.org/en/3.0/community/contributing/pr_workflow.html
+
+It is advisible to also install clang-format and copy the files in `misc/hooks` into `.git/hooks` so format checking is done before your changes are submitted.
+
+## Getting Started
+
+| **Build latest version of Godot** | [**GitHub**](https://github.com/godotengine/godot) | [**Docs**](https://godot.readthedocs.io/en/latest/development/compiling/index.html) |
+| --- | --- | --- |
+
+### Setting up a new project
+
+We recommend using git for managing your project and the instructions below assume so. Alternatively you can download the source code directly from GitHub in which case you need to download both [godot-cpp](https://github.com/GodotNativeTools/godot-cpp) and [godot_headers](https://github.com/GodotNativeTools/godot_headers).
 
-Getting latest `godot-cpp` and `godot_headers`
 ```
-$ git clone https://github.com/GodotNativeTools/godot-cpp
-$ git clone https://github.com/GodotNativeTools/godot_headers
-```
-right now our directory structure should look like this:
-```
-godot-cpp
-godot_headers
-SimpleLibrary
-├── lib/
-└── src/
+$ mkdir SimpleLibrary
+$ cd SimpleLibrary
+$ mkdir bin
+$ mkdir src
+$ git clone --recursive https://github.com/GodotNativeTools/godot-cpp
 ```
 
-Now to generate cpp bindings
+Note that if you wish to use a specific branch, add the -b option to the clone command:
+```
+$ git clone --recursive https://github.com/GodotNativeTools/godot-cpp -b 3.0
+```
+
+If your project is an existing repository, use git submodule instead:
+```
+$ git submodule add https://github.com/GodotNativeTools/godot-cpp
+$ git submodule update --init --recursive
+```
+
+Right now our directory structure should look like this:
+```
+SimpleLibrary/
+├─godot-cpp/
+| └─godot_headers/
+├─bin/
+└─src/
+```
+
+### Updating the api.json
+Our api.json file contains meta data of all the classes that are part of the Godot core and are needed to generate the C++ binding classes for use in GDNative modules. 
+
+This file is supplied with our godot_headers repository for your convinience but if you are running a custom build of Godot and need access to classes that have recent changes a new api.json file must be generated. You do this by starting your Godot executable with the following parameters:
+
+```
+$ godot --gdnative-generate-json-api api.json
+```
+
+Now copy the api.json file into your folder structure so its easy to access. **Note** the remark below for the extra ```custom_api_file``` command line parameter needed to tell scons where to find your file.
+
+### Compiling the cpp bindings library
+The final step is to compile our cpp bindings library:
 ```
 $ cd godot-cpp
-$ scons godotbinpath="../godot_fork/bin/godot_binary" p=linux
+$ scons platform=<your platform> generate_bindings=yes
 $ cd ..
 ```
-resulting libraries will be placed under `bin/` and the generated headers will be placed under `include/*`
 
-**Note:**
-> `generate_bindings=yes` is used to force regenerating C++ bindings (`godot_api.json` - Godot API)
+> Replace `<your platform>` with either `windows`, `linux` or `osx`.
 
 > Include `use_llvm=yes` for using clang++
 
-> You may need to specify `headers=../godot_headers` if you have compilation issues related to missing include files
+> Include `target=runtime` to build a runtime build (windows only at the moment)
 
-And our directory structure will be
-```
-godot-cpp
-└── bin/libgodot-cpp.a
-godot_headers
-SimpleLibrary
-├── lib/
-└── src/
-```
+> The resulting library will be created in `godot-cpp/bin/`, take note of its name as it will be different depending on platform.
 
-# Creating simple class
+> If you want to use an alternative api.json file add `use_custom_api_file=yes custom_api_file=../api.json`, be sure to specify the correct location of where you placed your file.
+
+## Creating a simple class
 
 Create `init.cpp` under `SimpleLibrary/src/` and add the following code
 ```cpp
-#include <core/Godot.hpp>
+#include <Godot.hpp>
 #include <Reference.hpp>
 
 using namespace godot;
 
-class SimpleClass : public GodotScript<Reference> {
-        GODOT_CLASS(SimpleClass);
+class SimpleClass : public Reference {
+    GODOT_CLASS(SimpleClass, Reference);
 public:
-        SimpleClass() { }
+    SimpleClass() { }
 
-        void test_void_method() {
-                Godot::print("This is test");
-        }
+    /* _init must exist as it is called by Godot */
+    void _init() { }
 
-        Variant method(Variant arg) {
-            Variant ret;
-            ret = arg;
+    void test_void_method() {
+        Godot::print("This is test");
+    }
 
-            return ret;
-        }
+    Variant method(Variant arg) {
+        Variant ret;
+        ret = arg;
 
-        static void _register_methods() {
-           register_method("method", &SimpleClass::method);
-	   
-	   /**
-	    * How to register exports like gdscript
-	    * export var _name = "SimpleClass"
-	    **/
-	   register_property((char *)"base/name", &SimpleClass::_name, String("SimpleClass"));
+        return ret;
+    }
 
-           /** For registering signal **/
-           // register_signal<SimpleClass>("signal_name");
-           // register_signal<SimpleClass>("signal_name", "string_argument", GODOT_VARIANT_TYPE_STRING)
-        }
-	
-	String _name;
+    static void _register_methods() {
+        register_method("method", &SimpleClass::method);
+        
+        /**
+         * How to register exports like gdscript
+         * export var _name = "SimpleClass"
+         **/
+        register_property<SimpleClass, String>("base/name", &SimpleClass::_name, String("SimpleClass"));
+
+        /* or alternatively with getter and setter methods */
+        register_property<SimpleClass, int>("base/value", &SimpleClass::set_value, &SimpleClass::get_value, 0);
+
+        /** For registering signal **/
+        // register_signal<SimpleClass>("signal_name");
+        // register_signal<SimpleClass>("signal_name", "string_argument", GODOT_VARIANT_TYPE_STRING)
+    }
+    
+    String _name;
+    int _value;
+
+    void set_value(int p_value) {
+        _value = p_value;
+    }
+
+    int get_value() const {
+        return _value;
+    }
 };
 
 /** GDNative Initialize **/
-extern "C" void GDN_EXPORT godot_gdnative_init(godot_gdnative_init_options *o)
-{
+extern "C" void GDN_EXPORT godot_gdnative_init(godot_gdnative_init_options *o) {
     godot::Godot::gdnative_init(o);
 }
 
 /** GDNative Terminate **/
-extern "C" void GDN_EXPORT godot_gdnative_terminate(godot_gdnative_terminate_options *o)
-{
+extern "C" void GDN_EXPORT godot_gdnative_terminate(godot_gdnative_terminate_options *o) {
     godot::Godot::gdnative_terminate(o);
 }
 
 /** NativeScript Initialize **/
-extern "C" void GDN_EXPORT godot_nativescript_init(void *handle)
-{
+extern "C" void GDN_EXPORT godot_nativescript_init(void *handle) {
     godot::Godot::nativescript_init(handle);
 
     godot::register_class<SimpleClass>();
 }
 ```
 
-# Compiling
+### Compiling
+
+*Linux*
 ```
 $ cd SimpleLibrary
-$ clang -fPIC -o src/init.os -c src/init.cpp -g -O3 -std=c++14 -I../godot-cpp/include -Igodot_headers
-$ clang -o lib/libtest.so -shared src/init.os -L../godot-cpp/lib -lgodot-cpp
+$ clang -fPIC -o src/init.os -c src/init.cpp -g -O3 -std=c++14 -Igodot-cpp/include -Igodot-cpp/include/core -Igodot-cpp/include/gen -Igodot-cpp/godot_headers
+$ clang -o bin/libtest.so -shared src/init.os -Lgodot-cpp/bin -l<name of the godot-cpp>
 ```
-This creates the file `libtest.so` in your `SimpleLibrary/lib` directory. For windows you need to find out what compiler flags need to be used.
+> This creates the file `libtest.so` in your `SimpleLibrary/bin` directory.
 
-# Creating `.gdns` file
+> You will need to replace `<name of the godot-cpp>` with the file that was created in [**Compiling the cpp bindings library**](#compiling-the-cpp-bindings-library)
+
+*Windows*
+```
+$ cd SimpleLibrary
+$ cl /Fosrc/init.obj /c src/init.cpp /nologo -EHsc -DNDEBUG /MDd /Igodot-cpp\include /Igodot-cpp\include\core /Igodot-cpp\include\gen /Igodot-cpp\godot_headers
+$ link /nologo /dll /out:bin\libtest.dll /implib:bin\libsimple.lib src\init.obj godot-cpp\bin\<name of the godot-cpp>
+```
+> This creates the file `libtest.dll` in your `SimpleLibrary/bin` directory.
+
+> You will need to replace `<name of the godot-cpp>` with the file that was created in [**Compiling the cpp bindings library**](#compiling-the-cpp-bindings-library)
+
+> Finally replace `/MDd` with `/MD` if you're generated a runtime build.
+
+*macOS*
+For OSX you need to find out what compiler flags need to be used.
+
+### Creating `.gdnlib` and `.gdns` files
 follow [godot_header/README.md](https://github.com/GodotNativeTools/godot_headers/blob/master/README.md#how-do-i-use-native-scripts-from-the-editor) to create the `.gdns` 
 
-# Implementing with gdscript
+### Implementing with gdscript
 ```gdscript
 var simpleclass = load("res://simpleclass.gdns").new();
 simpleclass.method("Test argument");

SConstruct

@@ -1,6 +1,6 @@
 #!python
 
-import os, subprocess, platform
+import os, subprocess, platform, sys
 
 
 def add_sources(sources, dir, extension):
@@ -8,100 +8,133 @@ def add_sources(sources, dir, extension):
       if f.endswith('.' + extension):
           sources.append(dir + '/' + f)
 
+# Try to detect the host platform automatically
+# This is used if no `platform` argument is passed
+if sys.platform.startswith('linux'):
+    host_platform = 'linux'
+elif sys.platform == 'darwin':
+    host_platform = 'osx'
+elif sys.platform == 'win32':
+    host_platform = 'windows'
+else:
+    raise ValueError('Could not detect platform automatically, please specify with platform=<platform>')
+
+opts = Variables([], ARGUMENTS)
+
+opts.Add(EnumVariable('platform', 'Target platform', host_platform,
+                    allowed_values=('linux', 'osx', 'windows'),
+                    ignorecase=2))
+opts.Add(EnumVariable('bits', 'Target platform bits', 'default', ('default', '32', '64')))
+opts.Add(BoolVariable('use_llvm', 'Use the LLVM compiler - only effective when targeting Linux', False))
+opts.Add(BoolVariable('use_mingw', 'Use the MinGW compiler - only effective on Windows', False))
+# Must be the same setting as used for cpp_bindings
+opts.Add(EnumVariable('target', 'Compilation target', 'debug',
+                    allowed_values=('debug', 'release'),
+                    ignorecase=2))
+opts.Add(PathVariable('headers_dir', 'Path to the directory containing Godot headers', 'godot_headers', PathVariable.PathIsDir))
+opts.Add(BoolVariable('use_custom_api_file', 'Use a custom JSON API file', False))
+opts.Add(PathVariable('custom_api_file', 'Path to the custom JSON API file', None, PathVariable.PathIsFile))
+opts.Add(BoolVariable('generate_bindings', 'Generate GDNative API bindings', False))
+
+unknown = opts.UnknownVariables()
+if unknown:
+    print("Unknown variables:" + unknown.keys())
+    Exit(1)
 
 env = Environment()
-host_platform = platform.system()
-target_platform = ARGUMENTS.get('p', ARGUMENTS.get('platform', 'linux'))
-target_arch = ARGUMENTS.get('a', ARGUMENTS.get('arch', '64'))
-# default to debug build, must be same setting as used for cpp_bindings
-target = ARGUMENTS.get('target', 'debug')
-# Local dependency paths, adapt them to your setup
-godot_headers = ARGUMENTS.get('headers', 'godot_headers')
-result_path = 'bin'
-result_name = ARGUMENTS.get('n', ARGUMENTS.get('name', os.path.relpath('.', '..')))
+opts.Update(env)
+Help(opts.GenerateHelpText(env))
 
+# This makes sure to keep the session environment variables on Windows
+# This way, you can run SCons in a Visual Studio 2017 prompt and it will find all the required tools
+if env['platform'] == 'windows':
+    if env['bits'] == '64':
+        env = Environment(TARGET_ARCH='amd64')
+    elif env['bits'] == '32':
+        env = Environment(TARGET_ARCH='x86')
+    else:
+        print("Warning: bits argument not specified, target arch is=" + env['TARGET_ARCH'])
+    opts.Update(env)
 
-if target_platform == 'linux':
-    result_name += '.linux.' + target_arch
+is64 = False
+if (env['platform'] == 'osx' or env['TARGET_ARCH'] == 'amd64' or env['TARGET_ARCH'] == 'emt64' or env['TARGET_ARCH'] == 'x86_64'):
+    is64 = True
+if env['bits'] == 'default':
+    env['bits'] = '64' if is64 else '32'
 
-    if ARGUMENTS.get('use_llvm', 'no') == 'yes':
+if env['platform'] == 'linux':
+    if env['use_llvm']:
         env['CXX'] = 'clang++'
 
-    env.Append(CCFLAGS = [ '-fPIC', '-g', '-std=c++14', '-Wwrite-strings' ])
-    env.Append(LINKFLAGS = [ '-Wl,-R,\'$$ORIGIN\'' ])
+    env.Append(CCFLAGS=['-fPIC', '-g', '-std=c++14', '-Wwrite-strings'])
+    env.Append(LINKFLAGS=["-Wl,-R,'$$ORIGIN'"])
 
-    if target == 'debug':
-        env.Append(CCFLAGS = ['-Og'])
+    if env['target'] == 'debug':
+        env.Append(CCFLAGS=['-Og'])
+    elif env['target'] == 'release':
+        env.Append(CCFLAGS=['-O3'])
+
+    if env['bits'] == '64':
+        env.Append(CCFLAGS=['-m64'])
+        env.Append(LINKFLAGS=['-m64'])
+    elif env['bits'] == '32':
+        env.Append(CCFLAGS=['-m32'])
+        env.Append(LINKFLAGS=['-m32'])
+
+elif env['platform'] == 'osx':
+    if env['bits'] == '32':
+        raise ValueError('Only 64-bit builds are supported for the macOS target.')
+
+    env.Append(CCFLAGS=['-g', '-std=c++14', '-arch', 'x86_64'])
+    env.Append(LINKFLAGS=['-arch', 'x86_64', '-framework', 'Cocoa', '-Wl,-undefined,dynamic_lookup'])
+
+    if env['target'] == 'debug':
+        env.Append(CCFLAGS=['-Og'])
+    elif env['target'] == 'release':
+        env.Append(CCFLAGS=['-O3'])
+
+elif env['platform'] == 'windows':
+    if host_platform == 'windows' and not env['use_mingw']:
+        # MSVC
+        env.Append(LINKFLAGS=['/WX'])
+        if env['target'] == 'debug':
+            env.Append(CCFLAGS=['/EHsc', '/D_DEBUG', '/MDd'])
+        elif env['target'] == 'release':
+            env.Append(CCFLAGS=['/O2', '/EHsc', '/DNDEBUG', '/MD'])
     else:
-        env.Append(CCFLAGS = ['-O3'])
+        # MinGW
+        if env['bits'] == '64':
+            env['CXX'] = 'x86_64-w64-mingw32-g++'
+        elif env['bits'] == '32':
+            env['CXX'] = 'i686-w64-mingw32-g++'
 
-    if target_arch == '32':
-        env.Append(CCFLAGS = [ '-m32' ])
-        env.Append(LINKFLAGS = [ '-m32' ])
-    elif target_arch == '64':
-        env.Append(CCFLAGS = [ '-m64' ])
-        env.Append(LINKFLAGS = [ '-m64' ])
-
-elif target_platform == 'windows':
-    # This makes sure to keep the session environment variables on windows,
-    # that way you can run scons in a vs 2017 prompt and it will find all the required tools
-    if (target_arch == '64'):
-        env = Environment(ENV = os.environ, TARGET_ARCH='amd64')
-    else:
-        env = Environment(ENV = os.environ, TARGET_ARCH='x86')
-
-    result_name += '.windows.' + target_arch
-
-    if host_platform == 'Windows':
-        result_name += '.lib'
-
-        env.Append(LINKFLAGS = [ '/WX' ])
-        if target == 'debug':
-            env.Append(CCFLAGS = ['/EHsc', '/D_DEBUG', '/MDd' ])
-        else:
-            env.Append(CCFLAGS = ['/O2', '/EHsc', '/DNDEBUG', '/MD' ])
-    else:
-        if target_arch == '32':
-            env['CXX']='i686-w64-mingw32-g++'
-        elif target_arch == '64':
-            env['CXX']='x86_64-w64-mingw32-g++'
-
-        env.Append(CCFLAGS = [ '-g', '-O3', '-std=c++14', '-Wwrite-strings' ])
-        env.Append(LINKFLAGS = [ '--static', '-Wl,--no-undefined', '-static-libgcc', '-static-libstdc++' ])
-
-elif target_platform == 'osx':
-    if ARGUMENTS.get('use_llvm', 'no') == 'yes':
-        env['CXX'] = 'clang++'
-
-    # Only 64-bits is supported for OS X
-    target_arch = '64'
-    result_name += '.osx.' + target_arch
-
-    env.Append(CCFLAGS = [ '-g','-O3', '-std=c++14', '-arch', 'x86_64' ])
-    env.Append(LINKFLAGS = [ '-arch', 'x86_64', '-framework', 'Cocoa', '-Wl,-undefined,dynamic_lookup' ])
+        env.Append(CCFLAGS=['-g', '-O3', '-std=c++14', '-Wwrite-strings'])
+        env.Append(LINKFLAGS=['--static', '-Wl,--no-undefined', '-static-libgcc', '-static-libstdc++'])
 
 
-env.Append(CPPPATH=['.', godot_headers, 'include', 'include/core'])
+env.Append(CPPPATH=['.', env['headers_dir'], 'include', 'include/gen', 'include/core'])
 
 # Generate bindings?
 json_api_file = ''
 
-if ARGUMENTS.get('use_custom_api_file', 'no') == 'yes':
-    json_api_file = ARGUMENTS.get('custom_api_file', '')
+if env['use_custom_api_file']:
+    json_api_file = env['custom_api_file']
 else:
-    json_api_file = os.path.join(os.getcwd(), 'godot_api.json')
+    json_api_file = os.path.join(os.getcwd(), 'godot_headers', 'api.json')
+
+if env['generate_bindings']:
+    # Actually create the bindings here
 
-if ARGUMENTS.get('generate_bindings', 'no') == 'yes':
-    # actually create the bindings here
-    
     import binding_generator
 
     binding_generator.generate_bindings(json_api_file)
 
+# source to compile
 sources = []
 add_sources(sources, 'src/core', 'cpp')
-add_sources(sources, 'src', 'cpp')
+add_sources(sources, 'src/gen', 'cpp')
 
-
-library = env.StaticLibrary(target=result_path + '/' + result_name, source=sources)
+library = env.StaticLibrary(
+    target='bin/' + 'libgodot-cpp.{}.{}.{}'.format(env['platform'], env['target'], env['bits']), source=sources
+)
 Default(library)

binding_generator.py

@@ -21,19 +21,22 @@ def generate_bindings(path):
         
         impl = generate_class_implementation(icalls, used_classes, c)
         
-        header_file = open("include/" + strip_name(c["name"]) + ".hpp", "w+")
+        header_file = open("include/gen/" + strip_name(c["name"]) + ".hpp", "w+")
         header_file.write(header)
         
-        source_file = open("src/" + strip_name(c["name"]) + ".cpp", "w+")
+        source_file = open("src/gen/" + strip_name(c["name"]) + ".cpp", "w+")
         source_file.write(impl)
     
     
-    icall_header_file = open("src/__icalls.hpp", "w+")
+    icall_header_file = open("src/gen/__icalls.hpp", "w+")
     icall_header_file.write(generate_icall_header(icalls))
     
-    icall_source_file = open("src/__icalls.cpp", "w+")
+    icall_source_file = open("src/gen/__icalls.cpp", "w+")
     icall_source_file.write(generate_icall_implementation(icalls))
 
+    register_types_file = open("src/gen/__register_types.cpp", "w+")
+    register_types_file.write(generate_type_registry(classes))
+
 
 def is_reference_type(t):
     for c in classes:
@@ -79,6 +82,8 @@ def generate_class_header(used_classes, c):
     # so don't include it here because it's not needed
     if class_name != "Object" and class_name != "Reference":
         source.append("#include <core/Ref.hpp>")
+    else:
+        source.append("#include <core/TagDB.hpp>")
 
 
     included = []
@@ -100,7 +105,6 @@ def generate_class_header(used_classes, c):
     if c["base_class"] != "":
         source.append("#include \"" + strip_name(c["base_class"]) + ".hpp\"")
         
-        
     
     source.append("namespace godot {")
     source.append("")
@@ -118,15 +122,40 @@ def generate_class_header(used_classes, c):
     vararg_templates = ""
     
     # generate the class definition here
-    source.append("class " + class_name + ("" if c["base_class"] == "" else (" : public " + strip_name(c["base_class"])) ) + " {")
-    
+    source.append("class " + class_name + (" : public _Wrapped" if c["base_class"] == "" else (" : public " + strip_name(c["base_class"])) ) + " {")
+
+    if c["base_class"] == "":
+        source.append("public: enum { ___CLASS_IS_SCRIPT = 0, };")
+        source.append("private:")
+        source.append("")
+
+    if c["singleton"]:
+        source.append("\tstatic " + class_name + " *_singleton;")
+        source.append("")
+        source.append("\t" + class_name + "();")
+        source.append("")
+
+
     source.append("public:")
     source.append("")
 
-    # ___get_class_name
-    source.append("\tstatic inline char *___get_class_name() { return (char *) \"" + strip_name(c["name"]) + "\"; }")
 
-    source.append("\tstatic inline Object *___get_from_variant(Variant a) { return (Object *) a; }")
+    if c["singleton"]:
+        source.append("\tstatic inline " + class_name + " *get_singleton()")
+        source.append("\t{")
+        source.append("\t\tif (!" + class_name + "::_singleton) {")
+        source.append("\t\t\t" + class_name + "::_singleton = new " + class_name + ";")
+        source.append("\t\t}")
+        source.append("\t\treturn " + class_name + "::_singleton;")
+        source.append("\t}")
+        source.append("")
+
+        # godot::api->godot_global_get_singleton((char *) \"" + strip_name(c["name"]) + "\");"
+
+    # ___get_class_name
+    source.append("\tstatic inline const char *___get_class_name() { return (const char *) \"" + strip_name(c["name"]) + "\"; }")
+
+    source.append("\tstatic inline Object *___get_from_variant(Variant a) { godot_object *o = (godot_object*) a; return (o) ? (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, o) : nullptr; }")
 
     enum_values = []
 
@@ -146,17 +175,26 @@ def generate_class_header(used_classes, c):
 
     
     if c["instanciable"]:
-        source.append("\tstatic void *operator new(size_t);")
-        
-        source.append("\tstatic void operator delete(void *);")
+        source.append("")
+        source.append("")
+        source.append("\tstatic " + class_name + " *_new();")
     
     source.append("\n\t// methods")
+
+
+    if class_name == "Object":
+        source.append("#ifndef GODOT_CPP_NO_OBJECT_CAST")
+        source.append("\ttemplate<class T>")
+        source.append("\tstatic T *cast_to(const Object *obj);")
+        source.append("#endif")
+        source.append("")
     
     for method in c["methods"]:
         
         method_signature = ""
         
-        method_signature += "static " if c["singleton"] else ""
+        # TODO decide what to do about virtual methods
+        # method_signature += "virtual " if method["is_virtual"] else ""
         method_signature += make_gdnative_type(method["return_type"])
         method_name = escape_cpp(method["name"])
         method_signature +=  method_name + "("
@@ -224,7 +262,7 @@ def generate_class_header(used_classes, c):
             vararg_templates += "\ttemplate <class... Args> " + method_signature + "Args... args){\n\t\treturn " + method_name + "(" + method_arguments + "Array::make(args...));\n\t}\n"""
             method_signature += "const Array& __var_args = Array()"
             
-        method_signature += ")" + (" const" if method["is_const"] and not c["singleton"] else "")
+        method_signature += ")" + (" const" if method["is_const"] else "")
             
 
         source.append("\t" + method_signature + ";")
@@ -234,11 +272,10 @@ def generate_class_header(used_classes, c):
     source.append("")
     
     
+
     source.append("}")
     source.append("")
     
-    
-    
     source.append("#endif")
     
     
@@ -279,23 +316,20 @@ def generate_class_implementation(icalls, used_classes, c):
     source.append("namespace godot {")
     
     
-    core_object_name = ("___static_object_" + strip_name(c["name"])) if c["singleton"] else "this"
+    core_object_name = "this"
     
     
     source.append("")
     source.append("")
-    
+
     if c["singleton"]:
-        source.append("static godot_object *" + core_object_name + ";")
+        source.append("" + class_name + " *" + class_name + "::_singleton = NULL;")
         source.append("")
         source.append("")
         
         # FIXME Test if inlining has a huge impact on binary size
-        source.append("static inline void ___singleton_init()")
-        source.append("{")
-        source.append("\tif (" + core_object_name + " == nullptr) {")
-        source.append("\t\t" + core_object_name + " = godot::api->godot_global_get_singleton((char *) \"" + strip_name(c["name"]) + "\");")
-        source.append("\t}")
+        source.append(class_name + "::" + class_name + "() {")
+        source.append("\t_owner = godot::api->godot_global_get_singleton((char *) \"" + strip_name(c["name"]) + "\");")
         source.append("}")
         
         source.append("")
@@ -304,18 +338,14 @@ def generate_class_implementation(icalls, used_classes, c):
     
     
     if c["instanciable"]:
-        source.append("void *" + strip_name(c["name"]) + "::operator new(size_t)")
+        source.append(class_name + " *" + strip_name(c["name"]) + "::_new()")
         source.append("{")
-        source.append("\treturn godot::api->godot_get_class_constructor((char *)\"" + c["name"] + "\")();")
-        source.append("}")
-        
-        source.append("void " + strip_name(c["name"]) + "::operator delete(void *ptr)")
-        source.append("{")
-        source.append("\tgodot::api->godot_object_destroy((godot_object *)ptr);")
+        source.append("\treturn (" + class_name + " *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, godot::api->godot_get_class_constructor((char *)\"" + c["name"] + "\")());")
         source.append("}")
     
     for method in c["methods"]:
         method_signature = ""
+
         
         method_signature += make_gdnative_type(method["return_type"])
         method_signature += strip_name(c["name"]) + "::" + escape_cpp(method["name"]) + "("
@@ -332,20 +362,23 @@ def generate_class_implementation(icalls, used_classes, c):
                 method_signature += ", "
             method_signature += "const Array& __var_args"
             
-        method_signature += ")" + (" const" if method["is_const"] and not c["singleton"] else "")
+        method_signature += ")" + (" const" if method["is_const"] else "")
     
         source.append(method_signature + " {")
+
+
+        if method["name"] == "free":
+            # dirty hack because Object::free is marked virtual but doesn't actually exist...
+            source.append("\tgodot::api->godot_object_destroy(_owner);")
+            source.append("}")
+            source.append("")
+            continue
+        else:
         
-        
-        
-        if c["singleton"]:
-            source.append("\t___singleton_init();")
-        
-        
-        source.append("\tstatic godot_method_bind *mb = nullptr;")
-        source.append("\tif (mb == nullptr) {")
-        source.append("\t\tmb = godot::api->godot_method_bind_get_method(\"" + c["name"] +"\", \"" + method["name"] + "\");")
-        source.append("\t}")
+            source.append("\tstatic godot_method_bind *mb = nullptr;")
+            source.append("\tif (mb == nullptr) {")
+            source.append("\t\tmb = godot::api->godot_method_bind_get_method(\"" + c["name"] +"\", \"" + method["name"] + "\");")
+            source.append("\t}")
         
         return_statement = ""
         
@@ -408,10 +441,17 @@ def generate_class_implementation(icalls, used_classes, c):
             source.append("")
             
             source.append("\tVariant __result;")
-            source.append("\t*(godot_variant *) &__result = godot::api->godot_method_bind_call(mb, (godot_object *) " + core_object_name + ", (const godot_variant **) __args, " + size + ", nullptr);")
+            source.append("\t*(godot_variant *) &__result = godot::api->godot_method_bind_call(mb, ((const Object *) " + core_object_name + ")->_owner, (const godot_variant **) __args, " + size + ", nullptr);")
             
             source.append("")
             
+            if is_class_type(method["return_type"]):
+                source.append("\tObject *obj = Object::___get_from_variant(__result);")
+                source.append("\tif (obj->has_method(\"reference\"))")
+                source.append("\t\tobj->callv(\"reference\", Array());")
+
+                source.append("")
+            
             
             for i, argument in enumerate(method["arguments"]):
                 source.append("\tgodot::api->godot_variant_destroy((godot_variant *) &__given_args[" + str(i) + "]);")
@@ -424,7 +464,7 @@ def generate_class_implementation(icalls, used_classes, c):
                     if is_reference_type(method["return_type"]):
                         cast += "Ref<" + strip_name(method["return_type"]) + ">::__internal_constructor(__result);"
                     else:
-                        cast += "(" + strip_name(method["return_type"]) + " *) (Object *) __result;"
+                        cast += "(" + strip_name(method["return_type"]) + " *) " + strip_name(method["return_type"] + "::___get_from_variant(") + "__result);"
                 else:
                     cast += "__result;"
                 source.append("\treturn " + cast)
@@ -445,7 +485,7 @@ def generate_class_implementation(icalls, used_classes, c):
             
             icall_name = get_icall_name(icall_sig)
             
-            return_statement += icall_name + "(mb, (godot_object *) " + core_object_name
+            return_statement += icall_name + "(mb, (const Object *) " + core_object_name
             
             for arg in method["arguments"]:
                 return_statement += ", " + escape_cpp(arg["name"]) + (".ptr()" if is_reference_type(arg["type"]) else "")
@@ -494,13 +534,15 @@ def generate_icall_header(icalls):
         
         method_signature = ""
         
-        method_signature += return_type(ret_type) + get_icall_name(icall) + "(godot_method_bind *mb, godot_object *inst"
+        method_signature += return_type(ret_type) + get_icall_name(icall) + "(godot_method_bind *mb, const Object *inst"
         
         for arg in args:
             method_signature += ", const "
             
             if is_core_type(arg):
                 method_signature += arg + "&"
+            elif arg == "int":
+                method_signature += "int64_t "
             elif arg == "float":
                 method_signature += "double "
             elif is_primitive(arg):
@@ -547,13 +589,15 @@ def generate_icall_implementation(icalls):
         
         method_signature = ""
         
-        method_signature += return_type(ret_type) + get_icall_name(icall) + "(godot_method_bind *mb, godot_object *inst"
+        method_signature += return_type(ret_type) + get_icall_name(icall) + "(godot_method_bind *mb, const Object *inst"
         
         for i, arg in enumerate(args):
             method_signature += ", const "
             
             if is_core_type(arg):
                 method_signature += arg + "& "
+            elif arg == "int":
+                method_signature += "int64_t "
             elif arg == "float":
                 method_signature += "double "
             elif is_primitive(arg):
@@ -568,7 +612,7 @@ def generate_icall_implementation(icalls):
         source.append(method_signature + " {")
         
         if ret_type != "void":
-            source.append("\t" + return_type(ret_type) + "ret;")
+            source.append("\t" + ("godot_object *" if is_class_type(ret_type) else return_type(ret_type)) + "ret;")
             if is_class_type(ret_type):
                 source.append("\tret = nullptr;")
         
@@ -581,7 +625,7 @@ def generate_icall_implementation(icalls):
             if is_primitive(arg) or is_core_type(arg):
                 wrapped_argument += "(void *) &arg" + str(i)
             else:
-                wrapped_argument += "(void *) arg" + str(i)
+                wrapped_argument += "(void *) (arg" + str(i) + ") ? arg" + str(i) + "->_owner : nullptr"
             
             wrapped_argument += ","
             source.append(wrapped_argument)
@@ -589,10 +633,17 @@ def generate_icall_implementation(icalls):
         source.append("\t};")
         source.append("")
         
-        source.append("\tgodot::api->godot_method_bind_ptrcall(mb, inst, args, " + ("nullptr" if ret_type == "void" else "&ret") + ");")
+        source.append("\tgodot::api->godot_method_bind_ptrcall(mb, inst->_owner, args, " + ("nullptr" if ret_type == "void" else "&ret") + ");")
         
         if ret_type != "void":
-            source.append("\treturn ret;")
+            if is_class_type(ret_type):
+                source.append("\tif (ret) {")
+                source.append("\t\treturn (Object *) godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, ret);")
+                source.append("\t}")
+                source.append("")
+                source.append("\treturn (Object *) ret;")
+            else:
+                source.append("\treturn ret;")
         
         source.append("}")
     
@@ -604,8 +655,44 @@ def generate_icall_implementation(icalls):
 
 
 
+def generate_type_registry(classes):
+    source = []
+    
+    source.append("#include \"TagDB.hpp\"")
+    source.append("#include <typeinfo>")
+    source.append("\n")
+
+    for c in classes:
+        source.append("#include <" + strip_name(c["name"]) + ".hpp>")
+
+    source.append("")
+    source.append("")
+
+    source.append("namespace godot {")
+
+    source.append("void ___register_types()")
+    source.append("{")
+
+    for c in classes:
+        class_name = strip_name(c["name"])
+        base_class_name = strip_name(c["base_class"])
+
+        class_type_hash = "typeid(" + class_name + ").hash_code()"
+
+        base_class_type_hash = "typeid(" + base_class_name + ").hash_code()"
+
+        if base_class_name == "":
+            base_class_type_hash = "0"
+
+        source.append("\tgodot::_TagDB::register_global_type(\"" + c["name"] + "\", " + class_type_hash + ", " + base_class_type_hash + ");")
+
+    source.append("}")
+
+    source.append("")
+    source.append("}")
 
 
+    return "\n".join(source)
 
 
 
@@ -664,6 +751,8 @@ def get_used_classes(c):
 
 
 def strip_name(name):
+    if len(name) == 0:
+        return name
     if name[0] == '_':
         return name[1:]
     return name
@@ -735,7 +824,8 @@ def escape_cpp(name):
         "export":   "_export",
         "template": "_template",
         "new":      "new_",
-        "operator": "_operator"
+        "operator": "_operator",
+        "typename": "_typename"
     }
     if name in escapes:
         return escapes[name]

include/core/AABB.hpp

@@ -17,40 +17,38 @@ public:
 	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);
+		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);
+		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; }
+	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 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
 
-	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;
+	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;
-
+	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;
@@ -63,21 +61,22 @@ public:
 	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;
+	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 */
+	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; }
-
-
+	inline AABB(const Vector3 &p_pos, const Vector3 &p_size) {
+		position = p_pos;
+		size = p_size;
+	}
 };
 
-}
+} // namespace godot
 
 #endif // RECT3_H

include/core/Array.hpp

@@ -21,57 +21,58 @@ class Object;
 
 class Array {
 	godot_array _godot_array;
+
 public:
 	Array();
-	Array(const Array & other);
-	Array & operator=(const Array & other);
+	Array(const Array &other);
+	Array &operator=(const Array &other);
 
-	Array(const PoolByteArray& a);
+	Array(const PoolByteArray &a);
 
-	Array(const PoolIntArray& a);
+	Array(const PoolIntArray &a);
 
-	Array(const PoolRealArray& a);
+	Array(const PoolRealArray &a);
 
-	Array(const PoolStringArray& a);
+	Array(const PoolStringArray &a);
 
-	Array(const PoolVector2Array& a);
+	Array(const PoolVector2Array &a);
 
-	Array(const PoolVector3Array& a);
+	Array(const PoolVector3Array &a);
 
-	Array(const PoolColorArray& a);
+	Array(const PoolColorArray &a);
 
 	template <class... Args>
 	static Array make(Args... args) {
 		return helpers::append_all(Array(), args...);
 	}
 
-	Variant& operator [](const int idx);
+	Variant &operator[](const int idx);
 
-	Variant operator [](const int idx) const;
+	Variant operator[](const int idx) const;
 
-	void append(const Variant& v);
+	void append(const Variant &v);
 
 	void clear();
 
-	int count(const Variant& v);
+	int count(const Variant &v);
 
 	bool empty() const;
 
-	void erase(const Variant& v);
+	void erase(const Variant &v);
 
 	Variant front() const;
 
 	Variant back() const;
 
-	int find(const Variant& what, const int from = 0);
+	int find(const Variant &what, const int from = 0);
 
-	int find_last(const Variant& what);
+	int find_last(const Variant &what);
 
-	bool has(const Variant& what) const;
+	bool has(const Variant &what) const;
 
 	uint32_t hash() const;
 
-	void insert(const int pos, const Variant& value);
+	void insert(const int pos, const Variant &value);
 
 	void invert();
 
@@ -81,9 +82,9 @@ public:
 
 	Variant pop_front();
 
-	void push_back(const Variant& v);
+	void push_back(const Variant &v);
 
-	void push_front(const Variant& v);
+	void push_front(const Variant &v);
 
 	void remove(const int idx);
 
@@ -91,16 +92,15 @@ public:
 
 	void resize(const int size);
 
-	int rfind(const Variant& what, const int from = -1);
+	int rfind(const Variant &what, const int from = -1);
 
 	void sort();
 
-	void sort_custom(Object *obj, const String& func);
+	void sort_custom(Object *obj, const String &func);
 
 	~Array();
-
 };
 
-}
+} // namespace godot
 
 #endif // ARRAY_H

include/core/Basis.hpp

@@ -16,27 +16,22 @@ public:
 		Vector3 x, y, z;
 	};
 
-	Basis(const Quat& p_quat); // euler
-	Basis(const Vector3& p_euler); // euler
-	Basis(const Vector3& p_axis, real_t p_phi);
+	Basis(const Quat &p_quat); // euler
+	Basis(const Vector3 &p_euler); // euler
+	Basis(const Vector3 &p_axis, real_t p_phi);
 
-	Basis(const Vector3& row0, const Vector3& row1, const Vector3& row2);
+	Basis(const Vector3 &row0, const Vector3 &row1, const Vector3 &row2);
 
 	Basis(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz);
 
 	Basis();
 
-
-
-
-
-	const Vector3& operator[](int axis) const;
-	Vector3& operator[](int axis);
+	const Vector3 &operator[](int axis) const;
+	Vector3 &operator[](int axis);
 
 	void invert();
 
-	bool isequal_approx(const Basis& a, const Basis& b) const;
-
+	bool isequal_approx(const Basis &a, const Basis &b) const;
 
 	bool is_orthogonal() const;
 
@@ -52,15 +47,15 @@ public:
 
 	Vector3 get_axis(int p_axis) const;
 
-	void set_axis(int p_axis, const Vector3& p_value);
+	void set_axis(int p_axis, const Vector3 &p_value);
 
-	void rotate(const Vector3& p_axis, real_t p_phi);
+	void rotate(const Vector3 &p_axis, real_t p_phi);
 
-	Basis rotated(const Vector3& p_axis, real_t p_phi) const;
+	Basis rotated(const Vector3 &p_axis, real_t p_phi) const;
 
-	void scale( const Vector3& p_scale );
+	void scale(const Vector3 &p_scale);
 
-	Basis scaled( const Vector3& p_scale ) const;
+	Basis scaled(const Vector3 &p_scale) const;
 
 	Vector3 get_scale() const;
 
@@ -70,32 +65,31 @@ public:
 	void set_euler_yxz(const Vector3 &p_euler);
 
 	inline Vector3 get_euler() const { return get_euler_yxz(); }
-	inline void set_euler(const Vector3& p_euler) { set_euler_yxz(p_euler); }
+	inline void set_euler(const Vector3 &p_euler) { set_euler_yxz(p_euler); }
 
 	// transposed dot products
-	real_t tdotx(const Vector3& v) const;
-	real_t tdoty(const Vector3& v) const;
-	real_t tdotz(const Vector3& v) const;
+	real_t tdotx(const Vector3 &v) const;
+	real_t tdoty(const Vector3 &v) const;
+	real_t tdotz(const Vector3 &v) const;
 
-	bool operator==(const Basis& p_matrix) const;
+	bool operator==(const Basis &p_matrix) const;
 
-	bool operator!=(const Basis& p_matrix) const;
+	bool operator!=(const Basis &p_matrix) const;
 
-	Vector3 xform(const Vector3& p_vector) const;
+	Vector3 xform(const Vector3 &p_vector) const;
 
-	Vector3 xform_inv(const Vector3& p_vector) const;
-	void operator*=(const Basis& p_matrix);
+	Vector3 xform_inv(const Vector3 &p_vector) const;
+	void operator*=(const Basis &p_matrix);
 
-	Basis operator*(const Basis& p_matrix) const;
+	Basis operator*(const Basis &p_matrix) const;
 
+	void operator+=(const Basis &p_matrix);
 
-	void operator+=(const Basis& p_matrix);
+	Basis operator+(const Basis &p_matrix) const;
 
-	Basis operator+(const Basis& p_matrix) const;
+	void operator-=(const Basis &p_matrix);
 
-	void operator-=(const Basis& p_matrix);
-
-	Basis operator-(const Basis& p_matrix) const;
+	Basis operator-(const Basis &p_matrix) const;
 
 	void operator*=(real_t p_val);
 
@@ -105,14 +99,12 @@ public:
 
 	void set_orthogonal_index(int p_index); // down below
 
-
 	operator String() const;
 
-	void get_axis_and_angle(Vector3 &r_axis,real_t& r_angle) const;
+	void get_axis_and_angle(Vector3 &r_axis, real_t &r_angle) const;
 
 	/* create / set */
 
-
 	void set(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz);
 
 	Vector3 get_column(int i) const;
@@ -120,9 +112,9 @@ public:
 	Vector3 get_row(int i) const;
 	Vector3 get_main_diagonal() const;
 
-	void set_row(int i, const Vector3& p_row);
+	void set_row(int i, const Vector3 &p_row);
 
-	Basis transpose_xform(const Basis& m) const;
+	Basis transpose_xform(const Basis &m) const;
 
 	void orthonormalize();
 
@@ -133,10 +125,8 @@ public:
 	Basis diagonalize();
 
 	operator Quat() const;
-
-
 };
 
-}
+} // namespace godot
 
 #endif // BASIS_H

include/core/Color.hpp

@@ -9,14 +9,11 @@
 
 namespace godot {
 
-
 struct Color {
 
-
 private:
 	// static float _parse_col(const String& p_str, int p_ofs);
 public:
-
 	union {
 
 		struct {
@@ -28,8 +25,8 @@ public:
 		float components[4];
 	};
 
-	inline bool operator==(const Color &p_color) const { return (r==p_color.r && g==p_color.g && b==p_color.b && a==p_color.a ); }
-	inline bool operator!=(const Color &p_color) const { return (r!=p_color.r || g!=p_color.g || b!=p_color.b || a!=p_color.a ); }
+	inline bool operator==(const Color &p_color) const { return (r == p_color.r && g == p_color.g && b == p_color.b && a == p_color.a); }
+	inline bool operator!=(const Color &p_color) const { return (r != p_color.r || g != p_color.g || b != p_color.b || a != p_color.a); }
 
 	uint32_t to_32() const;
 
@@ -43,12 +40,12 @@ public:
 
 	float get_v() const;
 
-	void set_hsv(float p_h, float p_s, float p_v, float p_alpha=1.0);
+	void set_hsv(float p_h, float p_s, float p_v, float p_alpha = 1.0);
 
-	inline float& operator[](int idx) {
+	inline float &operator[](int idx) {
 		return components[idx];
 	}
-	inline const float& operator[](int idx) const {
+	inline const float &operator[](int idx) const {
 		return components[idx];
 	}
 
@@ -60,21 +57,21 @@ public:
 
 	Color contrasted() const;
 
-	Color linear_interpolate(const Color& p_b, float p_t) const;
+	Color linear_interpolate(const Color &p_b, float p_t) const;
 
-	Color blend(const Color& p_over) const;
+	Color blend(const Color &p_over) const;
 
 	Color to_linear() const;
 
 	static Color hex(uint32_t p_hex);
 
-	static Color html(const String& p_color);
+	static Color html(const String &p_color);
 
-	static bool html_is_valid(const String& p_color);
+	static bool html_is_valid(const String &p_color);
 
-	String to_html(bool p_alpha=true) const;
+	String to_html(bool p_alpha = true) const;
 
-	bool operator<(const Color& p_color) const; //used in set keys
+	bool operator<(const Color &p_color) const; //used in set keys
 
 	operator String() const;
 
@@ -82,15 +79,23 @@ public:
 	 * No construct parameters, r=0, g=0, b=0. a=255
 	 */
 	inline Color() {
-		r=0; g=0; b=0; a=1.0;
+		r = 0;
+		g = 0;
+		b = 0;
+		a = 1.0;
 	}
 
 	/**
 	 * RGB / RGBA construct parameters. Alpha is optional, but defaults to 1.0
 	 */
-	inline Color(float p_r,float p_g,float p_b,float p_a=1.0) { r=p_r; g=p_g; b=p_b; a=p_a; }
+	inline Color(float p_r, float p_g, float p_b, float p_a = 1.0) {
+		r = p_r;
+		g = p_g;
+		b = p_b;
+		a = p_a;
+	}
 };
 
-}
+} // namespace godot
 
 #endif // COLOR_H

include/core/CoreTypes.hpp

@@ -12,8 +12,8 @@
 #include "Plane.hpp"
 #include "PoolArrays.hpp"
 #include "Quat.hpp"
-#include "Rect2.hpp"
 #include "RID.hpp"
+#include "Rect2.hpp"
 #include "String.hpp"
 #include "Transform.hpp"
 #include "Transform2D.hpp"
@@ -21,5 +21,6 @@
 #include "Vector2.hpp"
 #include "Vector3.hpp"
 
+#include "Wrapped.hpp"
 
 #endif // CORETYPES_H

include/core/Defs.hpp

@@ -1,7 +1,6 @@
 #ifndef DEFS_H
 #define DEFS_H
 
-
 namespace godot {
 
 enum class Error {
@@ -15,7 +14,7 @@ enum class Error {
 	ERR_FILE_NOT_FOUND,
 	ERR_FILE_BAD_DRIVE,
 	ERR_FILE_BAD_PATH,
-	ERR_FILE_NO_PERMISSION,	// (10)
+	ERR_FILE_NO_PERMISSION, // (10)
 	ERR_FILE_ALREADY_IN_USE,
 	ERR_FILE_CANT_OPEN,
 	ERR_FILE_CANT_WRITE,
@@ -25,12 +24,12 @@ enum class Error {
 	ERR_FILE_MISSING_DEPENDENCIES,
 	ERR_FILE_EOF,
 	ERR_CANT_OPEN, ///< Can't open a resource/socket/file
-	ERR_CANT_CREATE,		// (20)
+	ERR_CANT_CREATE, // (20)
 	ERR_QUERY_FAILED,
 	ERR_ALREADY_IN_USE,
 	ERR_LOCKED, ///< resource is locked
 	ERR_TIMEOUT,
-	ERR_CANT_CONNECT,		// (25)
+	ERR_CANT_CONNECT, // (25)
 	ERR_CANT_RESOLVE,
 	ERR_CONNECTION_ERROR,
 	ERR_CANT_AQUIRE_RESOURCE,
@@ -45,12 +44,12 @@ enum class Error {
 	ERR_METHOD_NOT_FOUND,
 	ERR_LINK_FAILED,
 	ERR_SCRIPT_FAILED,
-	ERR_CYCLIC_LINK,		// (40)
+	ERR_CYCLIC_LINK, // (40)
 	ERR_INVALID_DECLARATION,
 	ERR_DUPLICATE_SYMBOL,
 	ERR_PARSE_ERROR,
 	ERR_BUSY,
-	ERR_SKIP,			// (45)
+	ERR_SKIP, // (45)
 	ERR_HELP, ///< user requested help!!
 	ERR_BUG, ///< a bug in the software certainly happened, due to a double check failing or unexpected behavior.
 	ERR_PRINTER_ON_FIRE, /// the parallel port printer is engulfed in flames
@@ -58,82 +57,124 @@ enum class Error {
 	ERR_WTF = ERR_OMFG_THIS_IS_VERY_VERY_BAD ///< short version of the above
 };
 
-	namespace helpers {
-		template <typename T, typename ValueT>
-		T append_all (T appendable, ValueT value) {
-			appendable.append(value);
-			return appendable;
-		}
-
-		template <typename T, typename ValueT, typename... Args>
-		T append_all (T appendable, ValueT value, Args... args) {
-			appendable.append(value);
-			return append_all(appendable, args...);
-		}
-
-		template <typename T>
-		T append_all (T appendable) {
-			return appendable;
-		}
-
-		template <typename KV, typename KeyT, typename ValueT>
-		KV add_all (KV kv, KeyT key, ValueT value) {
-			kv[key] = value;
-			return kv;
-		}
-
-		template <typename KV, typename KeyT, typename ValueT, typename... Args>
-		KV add_all (KV kv, KeyT key, ValueT value, Args... args) {
-			kv[key] = value;
-			return add_all(kv, args...);
-		}
-
-		template <typename KV>
-		KV add_all (KV kv) {
-			return kv;
-		}
-	}
-
+namespace helpers {
+template <typename T, typename ValueT>
+T append_all(T appendable, ValueT value) {
+	appendable.append(value);
+	return appendable;
 }
 
+template <typename T, typename ValueT, typename... Args>
+T append_all(T appendable, ValueT value, Args... args) {
+	appendable.append(value);
+	return append_all(appendable, args...);
+}
+
+template <typename T>
+T append_all(T appendable) {
+	return appendable;
+}
+
+template <typename KV, typename KeyT, typename ValueT>
+KV add_all(KV kv, KeyT key, ValueT value) {
+	kv[key] = value;
+	return kv;
+}
+
+template <typename KV, typename KeyT, typename ValueT, typename... Args>
+KV add_all(KV kv, KeyT key, ValueT value, Args... args) {
+	kv[key] = value;
+	return add_all(kv, args...);
+}
+
+template <typename KV>
+KV add_all(KV kv) {
+	return kv;
+}
+} // namespace helpers
+
+} // namespace godot
+
 #include <stdio.h>
 
 typedef float real_t;
 
 #define CMP_EPSILON 0.00001
-#define CMP_EPSILON2 (CMP_EPSILON*CMP_EPSILON)
+#define CMP_EPSILON2 (CMP_EPSILON * CMP_EPSILON)
 #define Math_PI 3.14159265358979323846
 
 #define _PLANE_EQ_DOT_EPSILON 0.999
 #define _PLANE_EQ_D_EPSILON 0.0001
 
-
-#ifndef ERR_FAIL_COND_V
-#define ERR_FAIL_COND_V(cond, ret) do { if (cond) { return ret; } } while(0)
+// ERR/WARN macros
+#ifndef WARN_PRINT
+#define WARN_PRINT(msg)                  \
+	fprintf(stdout, "ERROR: %s\n", msg); \
+	fflush(stdout)
 #endif
 
+#ifndef WARN_PRINTS
+#define WARN_PRINTS(msg) WARN_PRINT((msg).utf8().get_data())
+#endif
+
+#ifndef ERR_PRINT
+#define ERR_PRINT(x) fprintf(stderr, "ERROR: %s\n", x)
+#endif
+
+#ifndef ERR_PRINTS
+#define ERR_PRINTS(msg) ERR_PRINT((msg).utf8().get_data())
+#endif
+
+#ifndef ERR_FAIL
+#define ERR_FAIL() ERR_PRINT("Failed")
+#endif
 
 #ifndef ERR_FAIL_V
-#define ERR_FAIL_V(a) return a
+#define ERR_FAIL_V(a) \
+	{                 \
+		ERR_FAIL();   \
+		return a;     \
+	}
+#endif
+
+#ifndef ERR_FAIL_COND
+#define ERR_FAIL_COND(a)   \
+	do {                   \
+		if (a) {           \
+			ERR_PRINT(#a); \
+			return;        \
+		}                  \
+	} while (0)
+#endif
+
+#ifndef ERR_FAIL_COND_V
+#define ERR_FAIL_COND_V(cond, ret) \
+	do {                           \
+		if (cond) {                \
+			ERR_PRINT(#cond);      \
+			return ret;            \
+		}                          \
+	} while (0)
 #endif
 
 #ifndef ERR_FAIL_INDEX
-#define ERR_FAIL_INDEX(a, b)
-#endif
-
-
-#ifndef ERR_PRINT
-#define ERR_PRINT(msg) fprintf(stderr, "ERROR: %S\n", (msg).unicode_str())
+#define ERR_FAIL_INDEX(a, b)   \
+	do {                       \
+		if (a < 0 || a >= b) { \
+			ERR_FAIL();        \
+			return;            \
+		}                      \
+	} while (0)
 #endif
 
 #ifndef ERR_FAIL_INDEX_V
-#define ERR_FAIL_INDEX_V(a, b, c)
+#define ERR_FAIL_INDEX_V(a, b, c) \
+	do {                          \
+		if (a < 0 || a >= b) {    \
+			ERR_FAIL();           \
+			return c;             \
+		}                         \
+	} while (0)
 #endif
 
-
-#ifndef ERR_FAIL_COND
-#define ERR_FAIL_COND(a) do { if (a) { fprintf(stderr, #a); return; } } while(0)
-#endif
-
-
 #endif // DEFS_H

include/core/Dictionary.hpp

@@ -11,10 +11,11 @@ namespace godot {
 
 class Dictionary {
 	godot_dictionary _godot_dictionary;
+
 public:
 	Dictionary();
-	Dictionary(const Dictionary & other);
-	Dictionary & operator=(const Dictionary & other);
+	Dictionary(const Dictionary &other);
+	Dictionary &operator=(const Dictionary &other);
 
 	template <class... Args>
 	static Dictionary make(Args... args) {
@@ -25,19 +26,19 @@ public:
 
 	bool empty() const;
 
-	void erase(const Variant& key);
+	void erase(const Variant &key);
 
-	bool has(const Variant& key) const;
+	bool has(const Variant &key) const;
 
-	bool has_all(const Array& keys) const;
+	bool has_all(const Array &keys) const;
 
 	uint32_t hash() const;
 
 	Array keys() const;
 
-	Variant &operator [](const Variant& key);
+	Variant &operator[](const Variant &key);
 
-	const Variant &operator [](const Variant& key) const;
+	const Variant &operator[](const Variant &key) const;
 
 	int size() const;
 
@@ -46,9 +47,8 @@ public:
 	Array values() const;
 
 	~Dictionary();
-
 };
 
-}
+} // namespace godot
 
 #endif // DICTIONARY_H

include/core/Godot.hpp

@@ -6,280 +6,239 @@
 
 #include <gdnative_api_struct.gen.h>
 #include <nativescript/godot_nativescript.h>
-
+#include <typeinfo>
 
 #include "CoreTypes.hpp"
-#include "Variant.hpp"
 #include "Ref.hpp"
+#include "TagDB.hpp"
+#include "Variant.hpp"
 
 #include "Object.hpp"
 
 #include "GodotGlobal.hpp"
 
+#include <GDNativeLibrary.hpp>
+#include <NativeScript.hpp>
 
 namespace godot {
 
-
-template<class T>
-T *as(Object *obj)
-{
-	return (T *) godot::nativescript_api->godot_nativescript_get_userdata(obj);
+template <class T>
+T *as(const Object *obj) {
+	return (obj) ? (T *)godot::nativescript_api->godot_nativescript_get_userdata(obj->_owner) : nullptr;
 }
 
+template <class T>
+T *get_wrapper(godot_object *obj) {
+	return (T *)godot::nativescript_1_1_api->godot_nativescript_get_instance_binding_data(godot::_RegisterState::language_index, obj);
+}
 
-template<class T>
-class GodotScript {
-public:
-	T *owner;
+#define GODOT_CLASS(Name, Base)                                                                                                                     \
+                                                                                                                                                    \
+public:                                                                                                                                             \
+	inline static const char *___get_type_name() { return static_cast<const char *>(#Name); }                                                       \
+	enum { ___CLASS_IS_SCRIPT = 1,                                                                                                                  \
+	};                                                                                                                                              \
+	inline static Name *_new() {                                                                                                                    \
+		godot::NativeScript *script = godot::NativeScript::_new();                                                                                  \
+		script->set_library(godot::get_wrapper<godot::GDNativeLibrary>((godot_object *)godot::gdnlib));                                             \
+		script->set_class_name(#Name);                                                                                                              \
+		Name *instance = godot::as<Name>(script->new_());                                                                                           \
+		return instance;                                                                                                                            \
+	}                                                                                                                                               \
+	inline static size_t ___get_id() { return typeid(Name).hash_code(); };                                                                          \
+	inline static size_t ___get_base_id() { return typeid(Base).hash_code(); };                                                                     \
+	inline static const char *___get_base_type_name() { return Base::___get_class_name(); }                                                         \
+	inline static Object *___get_from_variant(godot::Variant a) { return (godot::Object *)godot::as<Name>(godot::Object::___get_from_variant(a)); } \
+                                                                                                                                                    \
+private:
 
-	// GodotScript() {}
+#define GODOT_SUBCLASS(Name, Base)                                                                                                                  \
+                                                                                                                                                    \
+public:                                                                                                                                             \
+	inline static const char *___get_type_name() { return static_cast<const char *>(#Name); }                                                       \
+	enum { ___CLASS_IS_SCRIPT = 1,                                                                                                                  \
+	};                                                                                                                                              \
+	inline static Name *_new() {                                                                                                                    \
+		godot::NativeScript *script = godot::NativeScript::_new();                                                                                  \
+		script->set_library(godot::get_wrapper<godot::GDNativeLibrary>((godot_object *)godot::gdnlib));                                             \
+		script->set_class_name(#Name);                                                                                                              \
+		Name *instance = godot::as<Name>(script->new_());                                                                                           \
+		return instance;                                                                                                                            \
+	}                                                                                                                                               \
+	inline static size_t ___get_id() { return typeid(Name).hash_code(); };                                                                          \
+	inline static size_t ___get_base_id() { return typeid(Base).hash_code(); };                                                                     \
+	inline static const char *___get_base_type_name() { return #Base; }                                                                             \
+	inline static Object *___get_from_variant(godot::Variant a) { return (godot::Object *)godot::as<Name>(godot::Object::___get_from_variant(a)); } \
+                                                                                                                                                    \
+private:
 
-	void _init() {}
-	static const char *___get_base_type_name()
-	{
-		return T::___get_class_name();
-	}
-
-	static GodotScript<T> *___get_from_variant(Variant a)
-	{
-		return as<GodotScript<T> >((Object *) a);
-	}
-
-	static void _register_methods() {}
-};
-
-
-
-#define GODOT_CLASS(Name) \
-	public: inline static const char *___get_type_name() { return static_cast<const char *>(#Name); } \
-	private:
-
-#define GODOT_SUBCLASS(Name, Base) \
-	public: inline static const char *___get_type_name() { return static_cast<const char *>(#Name); } \
-	inline static const char *___get_base_type_name() { return static_cast<const char *>(#Base); } \
-	private:
-
-
-template<class T>
+template <class T>
 struct _ArgCast {
-	static T _arg_cast(Variant a)
-	{
+	static T _arg_cast(Variant a) {
 		return a;
 	}
 };
 
-template<class T>
-struct _ArgCast<T*> {
-	static T *_arg_cast(Variant a)
-	{
-		return (T *) T::___get_from_variant(a);
+template <class T>
+struct _ArgCast<T *> {
+	static T *_arg_cast(Variant a) {
+		return (T *)T::___get_from_variant(a);
 	}
 };
 
-template<>
+template <>
 struct _ArgCast<Variant> {
-	static Variant _arg_cast(Variant a)
-	{
+	static Variant _arg_cast(Variant a) {
 		return a;
 	}
 };
 
-
-
-
-
 // instance and destroy funcs
 
-template<class T>
-void *_godot_class_instance_func(godot_object *p, void *method_data)
-{
+template <class T>
+void *_godot_class_instance_func(godot_object *p, void *method_data) {
 	T *d = new T();
-	*(godot_object **) &d->owner = p;
+	d->_owner = p;
+	d->_type_tag = typeid(T).hash_code();
 	d->_init();
 	return d;
 }
 
-template<class T>
-void _godot_class_destroy_func(godot_object *p, void *method_data, void *data)
-{
-	T *d = (T *) data;
+template <class T>
+void _godot_class_destroy_func(godot_object *p, void *method_data, void *data) {
+	T *d = (T *)data;
 	delete d;
 }
 
-
-template<class T>
-void register_class()
-{
+template <class T>
+void register_class() {
 	godot_instance_create_func create = {};
 	create.create_func = _godot_class_instance_func<T>;
 
 	godot_instance_destroy_func destroy = {};
 	destroy.destroy_func = _godot_class_destroy_func<T>;
 
+	_TagDB::register_type(T::___get_id(), T::___get_base_id());
 
 	godot::nativescript_api->godot_nativescript_register_class(godot::_RegisterState::nativescript_handle, T::___get_type_name(), T::___get_base_type_name(), create, destroy);
+	godot::nativescript_1_1_api->godot_nativescript_set_type_tag(godot::_RegisterState::nativescript_handle, T::___get_type_name(), (const void *)typeid(T).hash_code());
 	T::_register_methods();
 }
 
-template<class T>
-void register_tool_class()
-{
+template <class T>
+void register_tool_class() {
 	godot_instance_create_func create = {};
 	create.create_func = _godot_class_instance_func<T>;
 
 	godot_instance_destroy_func destroy = {};
 	destroy.destroy_func = _godot_class_destroy_func<T>;
 
+	_TagDB::register_type(T::___get_id(), T::___get_base_id());
 
 	godot::nativescript_api->godot_nativescript_register_tool_class(godot::_RegisterState::nativescript_handle, T::___get_type_name(), T::___get_base_type_name(), create, destroy);
+	godot::nativescript_1_1_api->godot_nativescript_set_type_tag(godot::_RegisterState::nativescript_handle, T::___get_type_name(), (const void *)typeid(T).hash_code());
 	T::_register_methods();
 }
 
-
-
-
-
-
-
-
-
-
-
-
 // method registering
 
 typedef godot_variant (*__godot_wrapper_method)(godot_object *, void *, void *, int, godot_variant **);
 
-
-template<class T, class R, class ...args>
-const char *___get_method_class_name(R (T::*p)(args... a))
-{
+template <class T, class R, class... args>
+const char *___get_method_class_name(R (T::*p)(args... a)) {
 	return T::___get_type_name();
 }
 
-template<class T, class R, class ...args>
-const char *___get_method_class_name(R (T::*p)(args... a) const)
-{
+template <class T, class R, class... args>
+const char *___get_method_class_name(R (T::*p)(args... a) const) {
 	return T::___get_type_name();
 }
 
-
-
-
-
-
-
 // Okay, time for some template magic.
 // Many thanks to manpat from the GDL Discord Server.
 
-
 // This is stuff that's available in C++14 I think, but whatever.
 
-template<int... I>
-struct __Sequence{};
+template <int... I>
+struct __Sequence {};
 
-template<int N, int... I>
+template <int N, int... I>
 struct __construct_sequence {
-	using type = typename __construct_sequence<N-1, N-1, I...>::type;
+	using type = typename __construct_sequence<N - 1, N - 1, I...>::type;
 };
 
-template<int... I>
+template <int... I>
 struct __construct_sequence<0, I...> {
 	using type = __Sequence<I...>;
 };
 
-
 // Now the wrapping part.
-template<class T, class R, class... As>
+template <class T, class R, class... As>
 struct _WrappedMethod {
-	R (T::*f)(As...);
+	R(T::*f)
+	(As...);
 
-	template<int... I>
-	void apply(Variant* ret, T* obj, Variant** args, __Sequence<I...>) {
-		*ret = (obj->*f)( _ArgCast<As>::_arg_cast(*args[I])... );
+	template <int... I>
+	void apply(Variant *ret, T *obj, Variant **args, __Sequence<I...>) {
+		*ret = (obj->*f)(_ArgCast<As>::_arg_cast(*args[I])...);
 	}
 };
 
-template<class T, class... As>
+template <class T, class... As>
 struct _WrappedMethod<T, void, As...> {
 	void (T::*f)(As...);
 
-	template<int... I>
-	void apply(Variant* ret, T* obj, Variant** args, __Sequence<I...>) {
-		(obj->*f)( _ArgCast<As>::_arg_cast(*args[I])... );
+	template <int... I>
+	void apply(Variant *ret, T *obj, Variant **args, __Sequence<I...>) {
+		(obj->*f)(_ArgCast<As>::_arg_cast(*args[I])...);
 	}
 };
 
-
-template<class T, class R, class... As>
-godot_variant __wrapped_method(godot_object *, void *method_data, void *user_data, int num_args, godot_variant **args)
-{
+template <class T, class R, class... As>
+godot_variant __wrapped_method(godot_object *, void *method_data, void *user_data, int num_args, godot_variant **args) {
 	godot_variant v;
 	godot::api->godot_variant_new_nil(&v);
 
-	T *obj = (T *) user_data;
-	_WrappedMethod<T, R, As...> *method = (_WrappedMethod<T, R, As...>*) method_data;
+	T *obj = (T *)user_data;
+	_WrappedMethod<T, R, As...> *method = (_WrappedMethod<T, R, As...> *)method_data;
 
-	Variant *var = (Variant *) &v;
-	Variant **arg = (Variant **) args;
+	Variant *var = (Variant *)&v;
+	Variant **arg = (Variant **)args;
 
-	method->apply(var, obj, arg, typename __construct_sequence<sizeof...(As)>::type {});
+	method->apply(var, obj, arg, typename __construct_sequence<sizeof...(As)>::type{});
 
 	return v;
 }
 
-template<class T, class R, class... As>
-void *___make_wrapper_function(R (T::*f)(As...))
-{
+template <class T, class R, class... As>
+void *___make_wrapper_function(R (T::*f)(As...)) {
 	using MethodType = _WrappedMethod<T, R, As...>;
-	MethodType *p = (MethodType *) godot::api->godot_alloc(sizeof(MethodType));
+	MethodType *p = (MethodType *)godot::api->godot_alloc(sizeof(MethodType));
 	p->f = f;
-	return (void *) p;
+	return (void *)p;
 }
 
-template<class T, class R, class... As>
-__godot_wrapper_method ___get_wrapper_function(R (T::*f)(As...))
-{
-	return (__godot_wrapper_method) &__wrapped_method<T, R, As...>;
+template <class T, class R, class... As>
+__godot_wrapper_method ___get_wrapper_function(R (T::*f)(As...)) {
+	return (__godot_wrapper_method)&__wrapped_method<T, R, As...>;
 }
 
-
-
-
-
-template<class T, class R, class ...A>
-void *___make_wrapper_function(R (T::*f)(A...) const)
-{
-	return ___make_wrapper_function((R (T::*)(A...)) f);
+template <class T, class R, class... A>
+void *___make_wrapper_function(R (T::*f)(A...) const) {
+	return ___make_wrapper_function((R(T::*)(A...))f);
 }
 
-
-template<class T, class R, class ...A>
-__godot_wrapper_method ___get_wrapper_function(R (T::*f)(A...) const)
-{
-	return ___get_wrapper_function((R (T::*)(A...)) f);
+template <class T, class R, class... A>
+__godot_wrapper_method ___get_wrapper_function(R (T::*f)(A...) const) {
+	return ___get_wrapper_function((R(T::*)(A...))f);
 }
 
-
-
-
-
-
-
-
-
-
-
-
-
-template<class M>
-void register_method(const char *name, M method_ptr, godot_method_rpc_mode rpc_type = GODOT_METHOD_RPC_MODE_DISABLED)
-{
+template <class M>
+void register_method(const char *name, M method_ptr, godot_method_rpc_mode rpc_type = GODOT_METHOD_RPC_MODE_DISABLED) {
 	godot_instance_method method = {};
 	method.method_data = ___make_wrapper_function(method_ptr);
 	method.free_func = godot::api->godot_free;
-	method.method = (__godot_wrapper_method) ___get_wrapper_function(method_ptr);
-
+	method.method = (__godot_wrapper_method)___get_wrapper_function(method_ptr);
 
 	godot_method_attributes attr = {};
 	attr.rpc_type = rpc_type;
@@ -287,34 +246,31 @@ void register_method(const char *name, M method_ptr, godot_method_rpc_mode rpc_t
 	godot::nativescript_api->godot_nativescript_register_method(godot::_RegisterState::nativescript_handle, ___get_method_class_name(method_ptr), name, attr, method);
 }
 
-
-
-template<class T, class P>
+template <class T, class P>
 struct _PropertySetFunc {
 	void (T::*f)(P);
-	static void _wrapped_setter(godot_object *object, void *method_data, void *user_data, godot_variant *value)
-	{
-		_PropertySetFunc<T, P> *set_func = (_PropertySetFunc<T, P> *) method_data;
-		T *obj = (T *) user_data;
+	static void _wrapped_setter(godot_object *object, void *method_data, void *user_data, godot_variant *value) {
+		_PropertySetFunc<T, P> *set_func = (_PropertySetFunc<T, P> *)method_data;
+		T *obj = (T *)user_data;
 
-		Variant *v = (Variant *) value;
+		Variant *v = (Variant *)value;
 
 		(obj->*(set_func->f))(_ArgCast<P>::_arg_cast(*v));
 	}
 };
 
-template<class T, class P>
+template <class T, class P>
 struct _PropertyGetFunc {
-	P (T::*f)();
-	static godot_variant _wrapped_getter(godot_object *object, void *method_data, void *user_data)
-	{
-		_PropertyGetFunc<T, P> *get_func = (_PropertyGetFunc<T, P> *) method_data;
-		T *obj = (T *) user_data;
+	P(T::*f)
+	();
+	static godot_variant _wrapped_getter(godot_object *object, void *method_data, void *user_data) {
+		_PropertyGetFunc<T, P> *get_func = (_PropertyGetFunc<T, P> *)method_data;
+		T *obj = (T *)user_data;
 
 		godot_variant var;
 		godot::api->godot_variant_new_nil(&var);
 
-		Variant *v = (Variant *) &var;
+		Variant *v = (Variant *)&var;
 
 		*v = (obj->*(get_func->f))();
 
@@ -322,37 +278,30 @@ struct _PropertyGetFunc {
 	}
 };
 
-
-
-
-
-
-template<class T, class P>
+template <class T, class P>
 struct _PropertyDefaultSetFunc {
-	P (T::*f);
-	static void _wrapped_setter(godot_object *object, void *method_data, void *user_data, godot_variant *value)
-	{
-		_PropertyDefaultSetFunc<T, P> *set_func = (_PropertyDefaultSetFunc<T, P> *) method_data;
-		T *obj = (T *) user_data;
+	P(T::*f);
+	static void _wrapped_setter(godot_object *object, void *method_data, void *user_data, godot_variant *value) {
+		_PropertyDefaultSetFunc<T, P> *set_func = (_PropertyDefaultSetFunc<T, P> *)method_data;
+		T *obj = (T *)user_data;
 
-		Variant *v = (Variant *) value;
+		Variant *v = (Variant *)value;
 
 		(obj->*(set_func->f)) = _ArgCast<P>::_arg_cast(*v);
 	}
 };
 
-template<class T, class P>
+template <class T, class P>
 struct _PropertyDefaultGetFunc {
-	P (T::*f);
-	static godot_variant _wrapped_getter(godot_object *object, void *method_data, void *user_data)
-	{
-		_PropertyDefaultGetFunc<T, P> *get_func = (_PropertyDefaultGetFunc<T, P> *) method_data;
-		T *obj = (T *) user_data;
+	P(T::*f);
+	static godot_variant _wrapped_getter(godot_object *object, void *method_data, void *user_data) {
+		_PropertyDefaultGetFunc<T, P> *get_func = (_PropertyDefaultGetFunc<T, P> *)method_data;
+		T *obj = (T *)user_data;
 
 		godot_variant var;
 		godot::api->godot_variant_new_nil(&var);
 
-		Variant *v = (Variant *) &var;
+		Variant *v = (Variant *)&var;
 
 		*v = (obj->*(get_func->f));
 
@@ -360,27 +309,25 @@ struct _PropertyDefaultGetFunc {
 	}
 };
 
-
-template<class T, class P>
-void register_property(const char *name, P (T::*var), P default_value, godot_method_rpc_mode rpc_mode = GODOT_METHOD_RPC_MODE_DISABLED,  godot_property_usage_flags usage = GODOT_PROPERTY_USAGE_DEFAULT, godot_property_hint hint = GODOT_PROPERTY_HINT_NONE, String hint_string = "")
-{
+template <class T, class P>
+void register_property(const char *name, P(T::*var), P default_value, godot_method_rpc_mode rpc_mode = GODOT_METHOD_RPC_MODE_DISABLED, godot_property_usage_flags usage = GODOT_PROPERTY_USAGE_DEFAULT, godot_property_hint hint = GODOT_PROPERTY_HINT_NONE, String hint_string = "") {
 	Variant def_val = default_value;
 
-	usage = (godot_property_usage_flags) ((int) usage | GODOT_PROPERTY_USAGE_SCRIPT_VARIABLE);
+	usage = (godot_property_usage_flags)((int)usage | GODOT_PROPERTY_USAGE_SCRIPT_VARIABLE);
 
 	if (def_val.get_type() == Variant::OBJECT) {
-		Object *o = def_val;
+		Object *o = get_wrapper<Object>(def_val.operator godot_object *());
 		if (o && o->is_class("Resource")) {
-			hint = (godot_property_hint) ((int) hint | GODOT_PROPERTY_HINT_RESOURCE_TYPE);
+			hint = (godot_property_hint)((int)hint | GODOT_PROPERTY_HINT_RESOURCE_TYPE);
 			hint_string = o->get_class();
 		}
 	}
 
-	godot_string *_hint_string = (godot_string*) &hint_string;
+	godot_string *_hint_string = (godot_string *)&hint_string;
 
 	godot_property_attributes attr = {};
 	attr.type = def_val.get_type();
-	attr.default_value = *(godot_variant *) &def_val;
+	attr.default_value = *(godot_variant *)&def_val;
 	attr.hint = hint;
 	attr.rset_type = rpc_mode;
 	attr.usage = usage;
@@ -389,75 +336,68 @@ void register_property(const char *name, P (T::*var), P default_value, godot_met
 	_PropertyDefaultSetFunc<T, P> *wrapped_set = (_PropertyDefaultSetFunc<T, P> *)godot::api->godot_alloc(sizeof(_PropertyDefaultSetFunc<T, P>));
 	wrapped_set->f = var;
 
-	_PropertyDefaultGetFunc<T, P> *wrapped_get = (_PropertyDefaultGetFunc<T, P> *) godot::api->godot_alloc(sizeof(_PropertyDefaultGetFunc<T, P>));
+	_PropertyDefaultGetFunc<T, P> *wrapped_get = (_PropertyDefaultGetFunc<T, P> *)godot::api->godot_alloc(sizeof(_PropertyDefaultGetFunc<T, P>));
 	wrapped_get->f = var;
 
 	godot_property_set_func set_func = {};
-	set_func.method_data = (void *) wrapped_set;
-	set_func.free_func   = godot::api->godot_free;
-	set_func.set_func    = &_PropertyDefaultSetFunc<T, P>::_wrapped_setter;
+	set_func.method_data = (void *)wrapped_set;
+	set_func.free_func = godot::api->godot_free;
+	set_func.set_func = &_PropertyDefaultSetFunc<T, P>::_wrapped_setter;
 
 	godot_property_get_func get_func = {};
-	get_func.method_data = (void *) wrapped_get;
-	get_func.free_func   = godot::api->godot_free;
-	get_func.get_func    = &_PropertyDefaultGetFunc<T, P>::_wrapped_getter;
+	get_func.method_data = (void *)wrapped_get;
+	get_func.free_func = godot::api->godot_free;
+	get_func.get_func = &_PropertyDefaultGetFunc<T, P>::_wrapped_getter;
 
 	godot::nativescript_api->godot_nativescript_register_property(godot::_RegisterState::nativescript_handle, T::___get_type_name(), name, &attr, set_func, get_func);
 }
 
-
-
-
-template<class T, class P>
-void register_property(const char *name, void (T::*setter)(P), P (T::*getter)(), P default_value, godot_method_rpc_mode rpc_mode = GODOT_METHOD_RPC_MODE_DISABLED,  godot_property_usage_flags usage = GODOT_PROPERTY_USAGE_DEFAULT, godot_property_hint hint = GODOT_PROPERTY_HINT_NONE, String hint_string = "")
-{
+template <class T, class P>
+void register_property(const char *name, void (T::*setter)(P), P (T::*getter)(), P default_value, godot_method_rpc_mode rpc_mode = GODOT_METHOD_RPC_MODE_DISABLED, godot_property_usage_flags usage = GODOT_PROPERTY_USAGE_DEFAULT, godot_property_hint hint = GODOT_PROPERTY_HINT_NONE, String hint_string = "") {
 	Variant def_val = default_value;
 
 	godot_property_attributes attr = {};
 	attr.type = def_val.get_type();
-	attr.default_value = *(godot_variant *) &def_val;
+	attr.default_value = *(godot_variant *)&def_val;
 	attr.hint = hint;
 	attr.rset_type = rpc_mode;
 	attr.usage = usage;
 
-	_PropertySetFunc<T, P> *wrapped_set = (_PropertySetFunc<T, P> *) godot::api->godot_alloc(sizeof(_PropertySetFunc<T, P>));
+	_PropertySetFunc<T, P> *wrapped_set = (_PropertySetFunc<T, P> *)godot::api->godot_alloc(sizeof(_PropertySetFunc<T, P>));
 	wrapped_set->f = setter;
 
-	_PropertyGetFunc<T, P> *wrapped_get = (_PropertyGetFunc<T, P> *) godot::api->godot_alloc(sizeof(_PropertyGetFunc<T, P>));
+	_PropertyGetFunc<T, P> *wrapped_get = (_PropertyGetFunc<T, P> *)godot::api->godot_alloc(sizeof(_PropertyGetFunc<T, P>));
 	wrapped_get->f = getter;
 
 	godot_property_set_func set_func = {};
-	set_func.method_data = (void *) wrapped_set;
-	set_func.free_func   = godot::api->godot_free;
-	set_func.set_func    = &_PropertySetFunc<T, P>::_wrapped_setter;
+	set_func.method_data = (void *)wrapped_set;
+	set_func.free_func = godot::api->godot_free;
+	set_func.set_func = &_PropertySetFunc<T, P>::_wrapped_setter;
 
 	godot_property_get_func get_func = {};
-	get_func.method_data = (void *) wrapped_get;
-	get_func.free_func   = godot::api->godot_free;
-	get_func.get_func    = &_PropertyGetFunc<T, P>::_wrapped_getter;
+	get_func.method_data = (void *)wrapped_get;
+	get_func.free_func = godot::api->godot_free;
+	get_func.get_func = &_PropertyGetFunc<T, P>::_wrapped_getter;
 
 	godot::nativescript_api->godot_nativescript_register_property(godot::_RegisterState::nativescript_handle, T::___get_type_name(), name, &attr, set_func, get_func);
-
 }
 
-template<class T, class P>
-void register_property(const char *name, void (T::*setter)(P), P (T::*getter)() const, P default_value, godot_method_rpc_mode rpc_mode = GODOT_METHOD_RPC_MODE_DISABLED,  godot_property_usage_flags usage = GODOT_PROPERTY_USAGE_DEFAULT, godot_property_hint hint = GODOT_PROPERTY_HINT_NONE, String hint_string = "")
-{
-	register_property(name, setter, (P (T::*)()) getter, default_value, rpc_mode, usage, hint, hint_string);
+template <class T, class P>
+void register_property(const char *name, void (T::*setter)(P), P (T::*getter)() const, P default_value, godot_method_rpc_mode rpc_mode = GODOT_METHOD_RPC_MODE_DISABLED, godot_property_usage_flags usage = GODOT_PROPERTY_USAGE_DEFAULT, godot_property_hint hint = GODOT_PROPERTY_HINT_NONE, String hint_string = "") {
+	register_property(name, setter, (P(T::*)())getter, default_value, rpc_mode, usage, hint, hint_string);
 }
 
-template<class T>
-void register_signal(String name, Dictionary args = Dictionary())
-{
+template <class T>
+void register_signal(String name, Dictionary args = Dictionary()) {
 	godot_signal signal = {};
 	signal.name = *(godot_string *)&name;
 	signal.num_args = args.size();
 	signal.num_default_args = 0;
 
 	// Need to check because malloc(0) is platform-dependent. Zero arguments will leave args to nullptr.
-	if(signal.num_args != 0) {
-		signal.args = (godot_signal_argument*) godot::api->godot_alloc(sizeof(godot_signal_argument) * signal.num_args);
-		memset((void *) signal.args, 0, sizeof(godot_signal_argument) * signal.num_args);
+	if (signal.num_args != 0) {
+		signal.args = (godot_signal_argument *)godot::api->godot_alloc(sizeof(godot_signal_argument) * signal.num_args);
+		memset((void *)signal.args, 0, sizeof(godot_signal_argument) * signal.num_args);
 	}
 
 	for (int i = 0; i < signal.num_args; i++) {
@@ -479,17 +419,42 @@ void register_signal(String name, Dictionary args = Dictionary())
 		godot::api->godot_string_destroy(&signal.args[i].name);
 	}
 
-	if(signal.args) {
+	if (signal.args) {
 		godot::api->godot_free(signal.args);
 	}
 }
 
-template<class T, class... Args>
-void register_signal(String name, Args... varargs)
-{
+template <class T, class... Args>
+void register_signal(String name, Args... varargs) {
 	register_signal<T>(name, Dictionary::make(varargs...));
 }
 
+#ifndef GODOT_CPP_NO_OBJECT_CAST
+template <class T>
+T *Object::cast_to(const Object *obj) {
+	if (!obj)
+		return nullptr;
+
+	size_t have_tag = (size_t)godot::nativescript_1_1_api->godot_nativescript_get_type_tag(obj->_owner);
+
+	if (have_tag) {
+		if (!godot::_TagDB::is_type_known((size_t)have_tag)) {
+			have_tag = 0;
+		}
+	}
+
+	if (!have_tag) {
+		have_tag = obj->_type_tag;
+	}
+
+	if (godot::_TagDB::is_type_compatible(typeid(T).hash_code(), have_tag)) {
+		return (T::___CLASS_IS_SCRIPT) ? godot::as<T>(obj) : (T *)obj;
+	} else {
+		return nullptr;
+	}
 }
+#endif
+
+} // namespace godot
 
 #endif // GODOT_H

include/core/GodotGlobal.hpp

@@ -1,39 +1,43 @@
 #ifndef GODOT_GLOBAL_HPP
 #define GODOT_GLOBAL_HPP
 
-#include <gdnative_api_struct.gen.h>
-#include "String.hpp"
 #include "Array.hpp"
-
+#include "String.hpp"
+#include <gdnative_api_struct.gen.h>
 
 namespace godot {
 
 extern "C" const godot_gdnative_core_api_struct *api;
 extern "C" const godot_gdnative_ext_nativescript_api_struct *nativescript_api;
+extern "C" const godot_gdnative_ext_nativescript_1_1_api_struct *nativescript_1_1_api;
+
+extern "C" const void *gdnlib;
 
 class Godot {
 
 public:
-	static void print(const String& message);
-	static void print_warning(const String& description, const String& function, const String& file, int line);
-	static void print_error(const String& description, const String& function, const String& file, int line);
+	static void print(const String &message);
+	static void print_warning(const String &description, const String &function, const String &file, int line);
+	static void print_error(const String &description, const String &function, const String &file, int line);
 
 	static void gdnative_init(godot_gdnative_init_options *o);
 	static void gdnative_terminate(godot_gdnative_terminate_options *o);
 	static void nativescript_init(void *handle);
+	static void nativescript_terminate(void *handle);
+
+	static void gdnative_profiling_add_data(const char *p_signature, uint64_t p_time);
 
 	template <class... Args>
-	static void print(const String& fmt, Args... values) {
+	static void print(const String &fmt, Args... values) {
 		print(fmt.format(Array::make(values...)));
 	}
 };
 
-
-
 struct _RegisterState {
 	static void *nativescript_handle;
+	static int language_index;
 };
 
-}
+} // namespace godot
 
 #endif

include/core/GodotProfiling.hpp

@@ -0,0 +1,34 @@
+#ifndef GODOT_PROFILING_HPP
+#define GODOT_PROFILING_HPP
+
+#include "OS.hpp"
+
+
+namespace godot {
+
+class FunctionProfiling {
+	char signature[1024];
+	uint64_t ticks;
+
+public:
+	FunctionProfiling(const char *p_function, const int p_line) {
+		snprintf(signature, 1024, "::%d::%s", p_line, p_function);
+		ticks = OS::get_singleton()->get_ticks_usec();
+	}
+	~FunctionProfiling() {
+		uint64_t t = OS::get_singleton()->get_ticks_usec() - ticks;
+		if (t > 0) {
+			Godot::gdnative_profiling_add_data(signature, t);
+		}
+	}
+};
+
+}
+
+#ifdef DEBUG_ENABLED
+#define GODOT_PROFILING_FUNCTION FunctionProfiling __function_profiling(__FUNCTION__, __LINE__);
+#else
+#define GODOT_PROFILING_FUNCTION
+#endif
+
+#endif

include/core/NodePath.hpp

@@ -7,16 +7,15 @@
 
 namespace godot {
 
-
-class NodePath
-{
+class NodePath {
 	godot_node_path _node_path;
+
 public:
 	NodePath();
 
 	NodePath(const NodePath &other);
 
-	NodePath(const String& from);
+	NodePath(const String &from);
 
 	NodePath(const char *contents);
 
@@ -34,15 +33,13 @@ public:
 
 	operator String() const;
 
-	void operator =(const NodePath& other);
+	void operator=(const NodePath &other);
 
-	bool operator ==(const NodePath& other);
+	bool operator==(const NodePath &other);
 
 	~NodePath();
 };
 
-
-
-}
+} // namespace godot
 
 #endif // NODEPATH_H

include/core/Plane.hpp

@@ -5,10 +5,8 @@
 
 #include <cmath>
 
-
 namespace godot {
 
-
 enum ClockDirection {
 
 	CLOCKWISE,
@@ -20,7 +18,7 @@ public:
 	Vector3 normal;
 	real_t d;
 
-	void set_normal(const Vector3& p_normal);
+	void set_normal(const Vector3 &p_normal);
 
 	inline Vector3 get_normal() const { return normal; } ///Point is coplanar, CMP_EPSILON for precision
 
@@ -30,40 +28,41 @@ public:
 
 	/* Plane-Point operations */
 
-	inline Vector3 center() const { return normal*d; }
+	inline Vector3 center() const { return normal * d; }
 	Vector3 get_any_point() const;
 	Vector3 get_any_perpendicular_normal() const;
 
 	bool is_point_over(const Vector3 &p_point) const; ///< Point is over plane
 	real_t distance_to(const Vector3 &p_point) const;
-	bool has_point(const Vector3 &p_point,real_t _epsilon=CMP_EPSILON) const;
+	bool has_point(const Vector3 &p_point, real_t _epsilon = CMP_EPSILON) const;
 
 	/* intersections */
 
-	bool intersect_3(const Plane &p_plane1, const Plane &p_plane2, Vector3 *r_result=0) const;
-	bool intersects_ray(Vector3 p_from, Vector3 p_dir, Vector3* p_intersection)  const;
-	bool intersects_segment(Vector3 p_begin, Vector3 p_end, Vector3* p_intersection)  const;
+	bool intersect_3(const Plane &p_plane1, const Plane &p_plane2, Vector3 *r_result = 0) const;
+	bool intersects_ray(Vector3 p_from, Vector3 p_dir, Vector3 *p_intersection) const;
+	bool intersects_segment(Vector3 p_begin, Vector3 p_end, Vector3 *p_intersection) const;
 
-	Vector3 project(const Vector3& p_point) const;
+	Vector3 project(const Vector3 &p_point) const;
 
 	/* misc */
 
-	inline Plane operator-() const { return Plane(-normal,-d); }
-	bool is_almost_like(const Plane& p_plane) const;
+	inline Plane operator-() const { return Plane(-normal, -d); }
+	bool is_almost_like(const Plane &p_plane) const;
 
-	bool operator==(const Plane& p_plane) const;
-	bool operator!=(const Plane& p_plane) const;
+	bool operator==(const Plane &p_plane) const;
+	bool operator!=(const Plane &p_plane) const;
 	operator String() const;
 
-	inline Plane() { d=0; }
-	inline Plane(real_t p_a, real_t p_b, real_t p_c, real_t p_d) : normal(p_a,p_b,p_c), d(p_d) { }
+	inline Plane() { d = 0; }
+	inline Plane(real_t p_a, real_t p_b, real_t p_c, real_t p_d) :
+			normal(p_a, p_b, p_c),
+			d(p_d) {}
 
 	Plane(const Vector3 &p_normal, real_t p_d);
-	Plane(const Vector3 &p_point, const Vector3& p_normal);
-	Plane(const Vector3 &p_point1, const Vector3 &p_point2,const Vector3 &p_point3,ClockDirection p_dir = CLOCKWISE);
-
+	Plane(const Vector3 &p_point, const Vector3 &p_normal);
+	Plane(const Vector3 &p_point1, const Vector3 &p_point2, const Vector3 &p_point3, ClockDirection p_dir = CLOCKWISE);
 };
 
-}
+} // namespace godot
 
 #endif // PLANE_H

include/core/PoolArrays.hpp

@@ -3,11 +3,11 @@
 
 #include "Defs.hpp"
 
-#include "String.hpp"
 #include "Color.hpp"
+#include "GodotGlobal.hpp"
+#include "String.hpp"
 #include "Vector2.hpp"
 #include "Vector3.hpp"
-#include "GodotGlobal.hpp"
 
 #include <gdnative/pool_arrays.h>
 
@@ -17,18 +17,19 @@ class Array;
 
 class PoolByteArray {
 	godot_pool_byte_array _godot_array;
-public:
 
+public:
 	class Read {
 
 		friend class PoolByteArray;
 		godot_pool_byte_array_read_access *_read_access;
+
 	public:
 		inline Read() {
 			_read_access = nullptr;
 		}
 
-		inline Read(const Read & p_other) {
+		inline Read(const Read &p_other) {
 			_read_access = godot::api->godot_pool_byte_array_read_access_copy(p_other._read_access);
 		}
 
@@ -44,7 +45,7 @@ public:
 			return ptr()[p_idx];
 		}
 
-		inline void operator=(const Read& p_other) {
+		inline void operator=(const Read &p_other) {
 			godot::api->godot_pool_byte_array_read_access_operator_assign(_read_access, p_other._read_access);
 		}
 	};
@@ -52,12 +53,13 @@ public:
 	class Write {
 		friend class PoolByteArray;
 		godot_pool_byte_array_write_access *_write_access;
+
 	public:
 		inline Write() {
 			_write_access = nullptr;
 		}
 
-		inline Write(const Write & p_other) {
+		inline Write(const Write &p_other) {
 			_write_access = godot::api->godot_pool_byte_array_write_access_copy(p_other._write_access);
 		}
 
@@ -73,16 +75,16 @@ public:
 			return ptr()[p_idx];
 		}
 
-		inline void operator=(const Write& p_other) {
+		inline void operator=(const Write &p_other) {
 			godot::api->godot_pool_byte_array_write_access_operator_assign(_write_access, p_other._write_access);
 		}
 	};
 
 	PoolByteArray();
 	PoolByteArray(const PoolByteArray &p_other);
-	PoolByteArray &operator=(const PoolByteArray & p_other);
+	PoolByteArray &operator=(const PoolByteArray &p_other);
 
-	PoolByteArray(const Array& array);
+	PoolByteArray(const Array &array);
 
 	Read read() const;
 
@@ -90,7 +92,7 @@ public:
 
 	void append(const uint8_t data);
 
-	void append_array(const PoolByteArray& array);
+	void append_array(const PoolByteArray &array);
 
 	int insert(const int idx, const uint8_t data);
 
@@ -104,27 +106,27 @@ public:
 
 	void set(const int idx, const uint8_t data);
 
-	uint8_t operator [](const int idx);
+	uint8_t operator[](const int idx);
 
 	int size() const;
 
 	~PoolByteArray();
 };
 
-
 class PoolIntArray {
 	godot_pool_int_array _godot_array;
-public:
 
+public:
 	class Read {
 		friend class PoolIntArray;
 		godot_pool_int_array_read_access *_read_access;
+
 	public:
 		inline Read() {
 			_read_access = nullptr;
 		}
 
-		inline Read(const Read & p_other) {
+		inline Read(const Read &p_other) {
 			_read_access = godot::api->godot_pool_int_array_read_access_copy(p_other._read_access);
 		}
 
@@ -140,7 +142,7 @@ public:
 			return ptr()[p_idx];
 		}
 
-		inline void operator=(const Read& p_other) {
+		inline void operator=(const Read &p_other) {
 			godot::api->godot_pool_int_array_read_access_operator_assign(_read_access, p_other._read_access);
 		}
 	};
@@ -148,12 +150,13 @@ public:
 	class Write {
 		friend class PoolIntArray;
 		godot_pool_int_array_write_access *_write_access;
+
 	public:
 		inline Write() {
 			_write_access = nullptr;
 		}
 
-		inline Write(const Write & p_other) {
+		inline Write(const Write &p_other) {
 			_write_access = godot::api->godot_pool_int_array_write_access_copy(p_other._write_access);
 		}
 
@@ -169,7 +172,7 @@ public:
 			return ptr()[p_idx];
 		}
 
-		inline void operator=(const Write& p_other) {
+		inline void operator=(const Write &p_other) {
 			godot::api->godot_pool_int_array_write_access_operator_assign(_write_access, p_other._write_access);
 		}
 	};
@@ -178,7 +181,7 @@ public:
 	PoolIntArray(const PoolIntArray &p_other);
 	PoolIntArray &operator=(const PoolIntArray &p_other);
 
-	PoolIntArray(const Array& array);
+	PoolIntArray(const Array &array);
 
 	Read read() const;
 
@@ -186,7 +189,7 @@ public:
 
 	void append(const int data);
 
-	void append_array(const PoolIntArray& array);
+	void append_array(const PoolIntArray &array);
 
 	int insert(const int idx, const int data);
 
@@ -200,27 +203,27 @@ public:
 
 	void set(const int idx, const int data);
 
-	int operator [](const int idx);
+	int operator[](const int idx);
 
 	int size() const;
 
 	~PoolIntArray();
 };
 
-
 class PoolRealArray {
 	godot_pool_real_array _godot_array;
-public:
 
+public:
 	class Read {
 		friend class PoolRealArray;
 		godot_pool_real_array_read_access *_read_access;
+
 	public:
 		inline Read() {
 			_read_access = nullptr;
 		}
 
-		inline Read(const Read & p_other) {
+		inline Read(const Read &p_other) {
 			_read_access = godot::api->godot_pool_real_array_read_access_copy(p_other._read_access);
 		}
 
@@ -236,7 +239,7 @@ public:
 			return ptr()[p_idx];
 		}
 
-		inline void operator=(const Read& p_other) {
+		inline void operator=(const Read &p_other) {
 			godot::api->godot_pool_real_array_read_access_operator_assign(_read_access, p_other._read_access);
 		}
 	};
@@ -244,12 +247,13 @@ public:
 	class Write {
 		friend class PoolRealArray;
 		godot_pool_real_array_write_access *_write_access;
+
 	public:
 		inline Write() {
 			_write_access = nullptr;
 		}
 
-		inline Write(const Write & p_other) {
+		inline Write(const Write &p_other) {
 			_write_access = godot::api->godot_pool_real_array_write_access_copy(p_other._write_access);
 		}
 
@@ -265,7 +269,7 @@ public:
 			return ptr()[p_idx];
 		}
 
-		inline void operator=(const Write& p_other) {
+		inline void operator=(const Write &p_other) {
 			godot::api->godot_pool_real_array_write_access_operator_assign(_write_access, p_other._write_access);
 		}
 	};
@@ -274,7 +278,7 @@ public:
 	PoolRealArray(const PoolRealArray &p_other);
 	PoolRealArray &operator=(const PoolRealArray &p_other);
 
-	PoolRealArray(const Array& array);
+	PoolRealArray(const Array &array);
 
 	Read read() const;
 
@@ -282,7 +286,7 @@ public:
 
 	void append(const real_t data);
 
-	void append_array(const PoolRealArray& array);
+	void append_array(const PoolRealArray &array);
 
 	int insert(const int idx, const real_t data);
 
@@ -296,27 +300,27 @@ public:
 
 	void set(const int idx, const real_t data);
 
-	real_t operator [](const int idx);
+	real_t operator[](const int idx);
 
 	int size() const;
 
 	~PoolRealArray();
 };
 
-
 class PoolStringArray {
 	godot_pool_string_array _godot_array;
-public:
 
+public:
 	class Read {
 		friend class PoolStringArray;
 		godot_pool_string_array_read_access *_read_access;
+
 	public:
 		inline Read() {
 			_read_access = nullptr;
 		}
 
-		inline Read(const Read & p_other) {
+		inline Read(const Read &p_other) {
 			_read_access = godot::api->godot_pool_string_array_read_access_copy(p_other._read_access);
 		}
 
@@ -325,14 +329,14 @@ public:
 		}
 
 		inline const String *ptr() const {
-			return (const String *) godot::api->godot_pool_string_array_read_access_ptr(_read_access);
+			return (const String *)godot::api->godot_pool_string_array_read_access_ptr(_read_access);
 		}
 
 		inline const String &operator[](int p_idx) const {
 			return ptr()[p_idx];
 		}
 
-		inline void operator=(const Read& p_other) {
+		inline void operator=(const Read &p_other) {
 			godot::api->godot_pool_string_array_read_access_operator_assign(_read_access, p_other._read_access);
 		}
 	};
@@ -340,12 +344,13 @@ public:
 	class Write {
 		friend class PoolStringArray;
 		godot_pool_string_array_write_access *_write_access;
+
 	public:
 		inline Write() {
 			_write_access = nullptr;
 		}
 
-		inline Write(const Write & p_other) {
+		inline Write(const Write &p_other) {
 			_write_access = godot::api->godot_pool_string_array_write_access_copy(p_other._write_access);
 		}
 
@@ -354,14 +359,14 @@ public:
 		}
 
 		inline String *ptr() const {
-			return (String *) godot::api->godot_pool_string_array_write_access_ptr(_write_access);
+			return (String *)godot::api->godot_pool_string_array_write_access_ptr(_write_access);
 		}
 
 		inline String &operator[](int p_idx) const {
 			return ptr()[p_idx];
 		}
 
-		inline void operator=(const Write& p_other) {
+		inline void operator=(const Write &p_other) {
 			godot::api->godot_pool_string_array_write_access_operator_assign(_write_access, p_other._write_access);
 		}
 	};
@@ -370,50 +375,49 @@ public:
 	PoolStringArray(const PoolStringArray &p_other);
 	PoolStringArray &operator=(const PoolStringArray &p_other);
 
-	PoolStringArray(const Array& array);
+	PoolStringArray(const Array &array);
 
 	Read read() const;
 
 	Write write();
 
-	void append(const String& data);
+	void append(const String &data);
 
-	void append_array(const PoolStringArray& array);
+	void append_array(const PoolStringArray &array);
 
-	int insert(const int idx, const String& data);
+	int insert(const int idx, const String &data);
 
 	void invert();
 
-	void push_back(const String& data);
+	void push_back(const String &data);
 
 	void remove(const int idx);
 
 	void resize(const int size);
 
-	void set(const int idx, const String& data);
+	void set(const int idx, const String &data);
 
-	const String operator [](const int idx);
+	const String operator[](const int idx);
 
 	int size() const;
 
 	~PoolStringArray();
 };
 
-
-
 class PoolVector2Array {
 	godot_pool_vector2_array _godot_array;
-public:
 
+public:
 	class Read {
 		friend class PoolVector2Array;
 		godot_pool_vector2_array_read_access *_read_access;
+
 	public:
 		inline Read() {
 			_read_access = nullptr;
 		}
 
-		inline Read(const Read & p_other) {
+		inline Read(const Read &p_other) {
 			_read_access = godot::api->godot_pool_vector2_array_read_access_copy(p_other._read_access);
 		}
 
@@ -422,14 +426,14 @@ public:
 		}
 
 		inline const Vector2 *ptr() const {
-			return (const Vector2 *) godot::api->godot_pool_vector2_array_read_access_ptr(_read_access);
+			return (const Vector2 *)godot::api->godot_pool_vector2_array_read_access_ptr(_read_access);
 		}
 
 		inline const Vector2 &operator[](int p_idx) const {
 			return ptr()[p_idx];
 		}
 
-		inline void operator=(const Read& p_other) {
+		inline void operator=(const Read &p_other) {
 			godot::api->godot_pool_vector2_array_read_access_operator_assign(_read_access, p_other._read_access);
 		}
 	};
@@ -437,12 +441,13 @@ public:
 	class Write {
 		friend class PoolVector2Array;
 		godot_pool_vector2_array_write_access *_write_access;
+
 	public:
 		inline Write() {
 			_write_access = nullptr;
 		}
 
-		inline Write(const Write & p_other) {
+		inline Write(const Write &p_other) {
 			_write_access = godot::api->godot_pool_vector2_array_write_access_copy(p_other._write_access);
 		}
 
@@ -451,14 +456,14 @@ public:
 		}
 
 		inline Vector2 *ptr() const {
-			return (Vector2 *) godot::api->godot_pool_vector2_array_write_access_ptr(_write_access);
+			return (Vector2 *)godot::api->godot_pool_vector2_array_write_access_ptr(_write_access);
 		}
 
 		inline Vector2 &operator[](int p_idx) const {
 			return ptr()[p_idx];
 		}
 
-		inline void operator=(const Write& p_other) {
+		inline void operator=(const Write &p_other) {
 			godot::api->godot_pool_vector2_array_write_access_operator_assign(_write_access, p_other._write_access);
 		}
 	};
@@ -467,49 +472,49 @@ public:
 	PoolVector2Array(const PoolVector2Array &p_other);
 	PoolVector2Array &operator=(const PoolVector2Array &p_other);
 
-	PoolVector2Array(const Array& array);
+	PoolVector2Array(const Array &array);
 
 	Read read() const;
 
 	Write write();
 
-	void append(const Vector2& data);
+	void append(const Vector2 &data);
 
-	void append_array(const PoolVector2Array& array);
+	void append_array(const PoolVector2Array &array);
 
-	int insert(const int idx, const Vector2& data);
+	int insert(const int idx, const Vector2 &data);
 
 	void invert();
 
-	void push_back(const Vector2& data);
+	void push_back(const Vector2 &data);
 
 	void remove(const int idx);
 
 	void resize(const int size);
 
-	void set(const int idx, const Vector2& data);
+	void set(const int idx, const Vector2 &data);
 
-	const Vector2 operator [](const int idx);
+	const Vector2 operator[](const int idx);
 
 	int size() const;
 
 	~PoolVector2Array();
 };
 
-
 class PoolVector3Array {
 	godot_pool_vector3_array _godot_array;
-public:
 
+public:
 	class Read {
 		friend class PoolVector3Array;
 		godot_pool_vector3_array_read_access *_read_access;
+
 	public:
 		inline Read() {
 			_read_access = nullptr;
 		}
 
-		inline Read(const Read & p_other) {
+		inline Read(const Read &p_other) {
 			_read_access = godot::api->godot_pool_vector3_array_read_access_copy(p_other._read_access);
 		}
 
@@ -518,14 +523,14 @@ public:
 		}
 
 		inline const Vector3 *ptr() const {
-			return (const Vector3 *) godot::api->godot_pool_vector3_array_read_access_ptr(_read_access);
+			return (const Vector3 *)godot::api->godot_pool_vector3_array_read_access_ptr(_read_access);
 		}
 
 		inline const Vector3 &operator[](int p_idx) const {
 			return ptr()[p_idx];
 		}
 
-		inline void operator=(const Read& p_other) {
+		inline void operator=(const Read &p_other) {
 			godot::api->godot_pool_vector3_array_read_access_operator_assign(_read_access, p_other._read_access);
 		}
 	};
@@ -533,12 +538,13 @@ public:
 	class Write {
 		friend class PoolVector3Array;
 		godot_pool_vector3_array_write_access *_write_access;
+
 	public:
 		inline Write() {
 			_write_access = nullptr;
 		}
 
-		inline Write(const Write & p_other) {
+		inline Write(const Write &p_other) {
 			_write_access = godot::api->godot_pool_vector3_array_write_access_copy(p_other._write_access);
 		}
 
@@ -547,14 +553,14 @@ public:
 		}
 
 		inline Vector3 *ptr() const {
-			return (Vector3 *) godot::api->godot_pool_vector3_array_write_access_ptr(_write_access);
+			return (Vector3 *)godot::api->godot_pool_vector3_array_write_access_ptr(_write_access);
 		}
 
 		inline Vector3 &operator[](int p_idx) const {
 			return ptr()[p_idx];
 		}
 
-		inline void operator=(const Write& p_other) {
+		inline void operator=(const Write &p_other) {
 			godot::api->godot_pool_vector3_array_write_access_operator_assign(_write_access, p_other._write_access);
 		}
 	};
@@ -563,49 +569,49 @@ public:
 	PoolVector3Array(const PoolVector3Array &p_other);
 	PoolVector3Array &operator=(const PoolVector3Array &p_other);
 
-	PoolVector3Array(const Array& array);
+	PoolVector3Array(const Array &array);
 
 	Read read() const;
 
 	Write write();
 
-	void append(const Vector3& data);
+	void append(const Vector3 &data);
 
-	void append_array(const PoolVector3Array& array);
+	void append_array(const PoolVector3Array &array);
 
-	int insert(const int idx, const Vector3& data);
+	int insert(const int idx, const Vector3 &data);
 
 	void invert();
 
-	void push_back(const Vector3& data);
+	void push_back(const Vector3 &data);
 
 	void remove(const int idx);
 
 	void resize(const int size);
 
-	void set(const int idx, const Vector3& data);
+	void set(const int idx, const Vector3 &data);
 
-	const Vector3 operator [](const int idx);
+	const Vector3 operator[](const int idx);
 
 	int size() const;
 
 	~PoolVector3Array();
 };
 
-
 class PoolColorArray {
 	godot_pool_color_array _godot_array;
-public:
 
+public:
 	class Read {
 		friend class PoolColorArray;
 		godot_pool_color_array_read_access *_read_access;
+
 	public:
 		inline Read() {
 			_read_access = nullptr;
 		}
 
-		inline Read(const Read & p_other) {
+		inline Read(const Read &p_other) {
 			_read_access = godot::api->godot_pool_color_array_read_access_copy(p_other._read_access);
 		}
 
@@ -614,14 +620,14 @@ public:
 		}
 
 		inline const Color *ptr() const {
-			return (const Color *) godot::api->godot_pool_color_array_read_access_ptr(_read_access);
+			return (const Color *)godot::api->godot_pool_color_array_read_access_ptr(_read_access);
 		}
 
 		inline const Color &operator[](int p_idx) const {
 			return ptr()[p_idx];
 		}
 
-		inline void operator=(const Read& p_other) {
+		inline void operator=(const Read &p_other) {
 			godot::api->godot_pool_color_array_read_access_operator_assign(_read_access, p_other._read_access);
 		}
 	};
@@ -629,12 +635,13 @@ public:
 	class Write {
 		friend class PoolColorArray;
 		godot_pool_color_array_write_access *_write_access;
+
 	public:
 		inline Write() {
 			_write_access = nullptr;
 		}
 
-		inline Write(const Write & p_other) {
+		inline Write(const Write &p_other) {
 			_write_access = godot::api->godot_pool_color_array_write_access_copy(p_other._write_access);
 		}
 
@@ -643,14 +650,14 @@ public:
 		}
 
 		inline Color *ptr() const {
-			return (Color *) godot::api->godot_pool_color_array_write_access_ptr(_write_access);
+			return (Color *)godot::api->godot_pool_color_array_write_access_ptr(_write_access);
 		}
 
 		inline Color &operator[](int p_idx) const {
 			return ptr()[p_idx];
 		}
 
-		inline void operator=(const Write& p_other) {
+		inline void operator=(const Write &p_other) {
 			godot::api->godot_pool_color_array_write_access_operator_assign(_write_access, p_other._write_access);
 		}
 	};
@@ -659,38 +666,35 @@ public:
 	PoolColorArray(const PoolColorArray &p_other);
 	PoolColorArray &operator=(const PoolColorArray &p_other);
 
-	PoolColorArray(const Array& array);
+	PoolColorArray(const Array &array);
 
 	Read read() const;
 
 	Write write();
 
-	void append(const Color& data);
+	void append(const Color &data);
 
-	void append_array(const PoolColorArray& array);
+	void append_array(const PoolColorArray &array);
 
-	int insert(const int idx, const Color& data);
+	int insert(const int idx, const Color &data);
 
 	void invert();
 
-	void push_back(const Color& data);
+	void push_back(const Color &data);
 
 	void remove(const int idx);
 
 	void resize(const int size);
 
-	void set(const int idx, const Color& data);
+	void set(const int idx, const Color &data);
 
-	const Color operator [](const int idx);
+	const Color operator[](const int idx);
 
 	int size() const;
 
 	~PoolColorArray();
 };
 
-
-
-
-}
+} // namespace godot
 
 #endif // POOLARRAYS_H

include/core/Quat.hpp

@@ -9,10 +9,9 @@
 
 namespace godot {
 
-class Quat{
+class Quat {
 public:
-
-	real_t x,y,z,w;
+	real_t x, y, z, w;
 
 	real_t length_squared() const;
 	real_t length() const;
@@ -23,65 +22,68 @@ public:
 
 	Quat inverse() const;
 
-	void set_euler_xyz(const Vector3& p_euler);
+	void set_euler_xyz(const Vector3 &p_euler);
 	Vector3 get_euler_xyz() const;
-	void set_euler_yxz(const Vector3& p_euler);
+	void set_euler_yxz(const Vector3 &p_euler);
 	Vector3 get_euler_yxz() const;
 
-	inline void set_euler(const Vector3& p_euler) { set_euler_yxz(p_euler); }
+	inline void set_euler(const Vector3 &p_euler) { set_euler_yxz(p_euler); }
 	inline Vector3 get_euler() const { return get_euler_yxz(); }
 
-	real_t dot(const Quat& q) const;
+	real_t dot(const Quat &q) const;
 
-	Quat slerp(const Quat& q, const real_t& t) const;
+	Quat slerp(const Quat &q, const real_t &t) const;
 
-	Quat slerpni(const Quat& q, const real_t& t) const;
+	Quat slerpni(const Quat &q, const real_t &t) const;
 
-	Quat cubic_slerp(const Quat& q, const Quat& prep, const Quat& postq,const real_t& t) const;
+	Quat cubic_slerp(const Quat &q, const Quat &prep, const Quat &postq, const real_t &t) const;
 
-	void get_axis_and_angle(Vector3& r_axis, real_t &r_angle) const;
+	void get_axis_and_angle(Vector3 &r_axis, real_t &r_angle) const;
 
-	void operator*=(const Quat& q);
-	Quat operator*(const Quat& q) const;
+	void operator*=(const Quat &q);
+	Quat operator*(const Quat &q) const;
 
+	Quat operator*(const Vector3 &v) const;
 
+	Vector3 xform(const Vector3 &v) const;
 
-	Quat operator*(const Vector3& v) const;
-
-	Vector3 xform(const Vector3& v) const;
-
-
-	void operator+=(const Quat& q);
-	void operator-=(const Quat& q);
-	void operator*=(const real_t& s);
-	void operator/=(const real_t& s);
-	Quat operator+(const Quat& q2) const;
-	Quat operator-(const Quat& q2) const;
+	void operator+=(const Quat &q);
+	void operator-=(const Quat &q);
+	void operator*=(const real_t &s);
+	void operator/=(const real_t &s);
+	Quat operator+(const Quat &q2) const;
+	Quat operator-(const Quat &q2) const;
 	Quat operator-() const;
-	Quat operator*(const real_t& s) const;
-	Quat operator/(const real_t& s) const;
+	Quat operator*(const real_t &s) const;
+	Quat operator/(const real_t &s) const;
 
-
-	bool operator==(const Quat& p_quat) const;
-	bool operator!=(const Quat& p_quat) const;
+	bool operator==(const Quat &p_quat) const;
+	bool operator!=(const Quat &p_quat) const;
 
 	operator String() const;
 
-	inline void set( real_t p_x, real_t p_y, real_t p_z, real_t p_w) {
-		x=p_x; y=p_y; z=p_z; w=p_w;
+	inline void set(real_t p_x, real_t p_y, real_t p_z, real_t p_w) {
+		x = p_x;
+		y = p_y;
+		z = p_z;
+		w = p_w;
 	}
 	inline Quat(real_t p_x, real_t p_y, real_t p_z, real_t p_w) {
-		x=p_x; y=p_y; z=p_z; w=p_w;
+		x = p_x;
+		y = p_y;
+		z = p_z;
+		w = p_w;
 	}
-	Quat(const Vector3& axis, const real_t& angle);
+	Quat(const Vector3 &axis, const real_t &angle);
 
-	Quat(const Vector3& v0, const Vector3& v1) ;
-
-	inline Quat() {x=y=z=0; w=1; }
+	Quat(const Vector3 &v0, const Vector3 &v1);
 
+	inline Quat() {
+		x = y = z = 0;
+		w = 1;
+	}
 };
 
-
-}
+} // namespace godot
 
 #endif // QUAT_H

include/core/RID.hpp

@@ -9,8 +9,8 @@ class Object;
 
 class RID {
 	godot_rid _godot_rid;
-public:
 
+public:
 	RID();
 
 	RID(Object *p);
@@ -22,15 +22,14 @@ public:
 		return *this != RID();
 	}
 
-	bool operator==(const RID & p_other) const;
-	bool operator!=(const RID & p_other) const;
-	bool operator<(const RID & p_other) const;
-	bool operator>(const RID & p_other) const;
-	bool operator<=(const RID & p_other) const;
-	bool operator>=(const RID & p_other) const;
-
+	bool operator==(const RID &p_other) const;
+	bool operator!=(const RID &p_other) const;
+	bool operator<(const RID &p_other) const;
+	bool operator>(const RID &p_other) const;
+	bool operator<=(const RID &p_other) const;
+	bool operator>=(const RID &p_other) const;
 };
 
-}
+} // namespace godot
 
 #endif // RID_H

include/core/Rect2.hpp

@@ -18,116 +18,118 @@ struct Transform2D;
 
 struct Rect2 {
 
-	Point2 pos;
+	Point2 position;
 	Size2 size;
 
-	inline const Vector2& get_pos() const { return pos; }
-	inline void set_pos(const Vector2& p_pos) { pos=p_pos; }
-	inline const Vector2& get_size() const { return size; }
-	inline void set_size(const Vector2& p_size) { size=p_size; }
+	inline const Vector2 &get_position() const { return position; }
+	inline void set_position(const Vector2 &p_position) { position = p_position; }
+	inline const Vector2 &get_size() const { return size; }
+	inline void set_size(const Vector2 &p_size) { size = p_size; }
 
-	inline real_t get_area() const { return size.width*size.height; }
+	inline real_t get_area() const { return size.width * size.height; }
 
-	inline bool intersects(const Rect2& p_rect) const {
-		if ( pos.x >= (p_rect.pos.x + p_rect.size.width) )
+	inline bool intersects(const Rect2 &p_rect) const {
+		if (position.x >= (p_rect.position.x + p_rect.size.width))
 			return false;
-		if ( (pos.x+size.width) <= p_rect.pos.x  )
+		if ((position.x + size.width) <= p_rect.position.x)
 			return false;
-		if ( pos.y >= (p_rect.pos.y + p_rect.size.height) )
+		if (position.y >= (p_rect.position.y + p_rect.size.height))
 			return false;
-		if ( (pos.y+size.height) <= p_rect.pos.y  )
+		if ((position.y + size.height) <= p_rect.position.y)
 			return false;
 
 		return true;
 	}
 
-	real_t distance_to(const Vector2& p_point) const;
+	real_t distance_to(const Vector2 &p_point) const;
 
-	bool intersects_transformed(const Transform2D& p_xform, const Rect2& p_rect) const;
+	bool intersects_transformed(const Transform2D &p_xform, const Rect2 &p_rect) const;
 
-	bool intersects_segment(const Point2& p_from, const Point2& p_to, Point2* r_pos=nullptr, Point2* r_normal=nullptr) const;
+	bool intersects_segment(const Point2 &p_from, const Point2 &p_to, Point2 *r_position = nullptr, Point2 *r_normal = nullptr) const;
 
-	inline bool encloses(const Rect2& p_rect) const {
-
-		return 	(p_rect.pos.x>=pos.x) && (p_rect.pos.y>=pos.y) &&
-			((p_rect.pos.x+p_rect.size.x)<(pos.x+size.x)) &&
-			((p_rect.pos.y+p_rect.size.y)<(pos.y+size.y));
+	inline bool encloses(const Rect2 &p_rect) const {
 
+		return (p_rect.position.x >= position.x) && (p_rect.position.y >= position.y) &&
+			   ((p_rect.position.x + p_rect.size.x) < (position.x + size.x)) &&
+			   ((p_rect.position.y + p_rect.size.y) < (position.y + size.y));
 	}
 
 	inline bool has_no_area() const {
 
-		return (size.x<=0 || size.y<=0);
-
+		return (size.x <= 0 || size.y <= 0);
 	}
-	Rect2 clip(const Rect2& p_rect) const;
+	Rect2 clip(const Rect2 &p_rect) const;
 
-	Rect2 merge(const Rect2& p_rect) const;
+	Rect2 merge(const Rect2 &p_rect) const;
 
-	inline bool has_point(const Point2& p_point) const {
-		if (p_point.x < pos.x)
+	inline bool has_point(const Point2 &p_point) const {
+		if (p_point.x < position.x)
 			return false;
-		if (p_point.y < pos.y)
+		if (p_point.y < position.y)
 			return false;
 
-		if (p_point.x >= (pos.x+size.x) )
+		if (p_point.x >= (position.x + size.x))
 			return false;
-		if (p_point.y >= (pos.y+size.y) )
+		if (p_point.y >= (position.y + size.y))
 			return false;
 
 		return true;
 	}
 
-	inline bool no_area() const { return (size.width<=0 || size.height<=0 ); }
+	inline bool no_area() const { return (size.width <= 0 || size.height <= 0); }
 
-	inline bool operator==(const Rect2& p_rect) const { return pos==p_rect.pos && size==p_rect.size; }
-	inline bool operator!=(const Rect2& p_rect) const { return pos!=p_rect.pos || size!=p_rect.size; }
+	inline bool operator==(const Rect2 &p_rect) const { return position == p_rect.position && size == p_rect.size; }
+	inline bool operator!=(const Rect2 &p_rect) const { return position != p_rect.position || size != p_rect.size; }
 
 	inline Rect2 grow(real_t p_by) const {
 
-		Rect2 g=*this;
-		g.pos.x-=p_by;
-		g.pos.y-=p_by;
-		g.size.width+=p_by*2;
-		g.size.height+=p_by*2;
+		Rect2 g = *this;
+		g.position.x -= p_by;
+		g.position.y -= p_by;
+		g.size.width += p_by * 2;
+		g.size.height += p_by * 2;
 		return g;
 	}
 
-	inline Rect2 expand(const Vector2& p_vector) const {
+	inline Rect2 expand(const Vector2 &p_vector) const {
 
 		Rect2 r = *this;
 		r.expand_to(p_vector);
 		return r;
 	}
 
-	inline void expand_to(const Vector2& p_vector) { //in place function for speed
+	inline void expand_to(const Vector2 &p_vector) { //in place function for speed
 
-		Vector2 begin=pos;
-		Vector2 end=pos+size;
+		Vector2 begin = position;
+		Vector2 end = position + size;
 
-		if (p_vector.x<begin.x)
-			begin.x=p_vector.x;
-		if (p_vector.y<begin.y)
-			begin.y=p_vector.y;
+		if (p_vector.x < begin.x)
+			begin.x = p_vector.x;
+		if (p_vector.y < begin.y)
+			begin.y = p_vector.y;
 
-		if (p_vector.x>end.x)
-			end.x=p_vector.x;
-		if (p_vector.y>end.y)
-			end.y=p_vector.y;
+		if (p_vector.x > end.x)
+			end.x = p_vector.x;
+		if (p_vector.y > end.y)
+			end.y = p_vector.y;
 
-		pos=begin;
-		size=end-begin;
+		position = begin;
+		size = end - begin;
 	}
 
-
 	operator String() const;
 
 	inline Rect2() {}
-	inline Rect2( real_t p_x, real_t p_y, real_t p_width, real_t p_height) { pos=Point2(p_x,p_y); size=Size2( p_width, p_height ); }
-	inline Rect2( const Point2& p_pos, const Size2& p_size ) { pos=p_pos; size=p_size; }
+	inline Rect2(real_t p_x, real_t p_y, real_t p_width, real_t p_height) {
+		position = Point2(p_x, p_y);
+		size = Size2(p_width, p_height);
+	}
+	inline Rect2(const Point2 &p_position, const Size2 &p_size) {
+		position = p_position;
+		size = p_size;
+	}
 };
 
-
-}
+} // namespace godot
 
 #endif // RECT2_H

include/core/Ref.hpp

@@ -1,9 +1,9 @@
 #ifndef REF_H
 #define REF_H
 
-#include "Variant.hpp"
 #include "GodotGlobal.hpp"
-#include "../Reference.hpp"
+#include "Reference.hpp"
+#include "Variant.hpp"
 
 namespace godot {
 
@@ -80,7 +80,7 @@ public:
 	operator Variant() const {
 		// Note: the C API handles the cases where the object is a Reference,
 		// so the Variant will be correctly constructed with a RefPtr engine-side
-		return Variant((Object*)reference);
+		return Variant((Object *)reference);
 	}
 
 	void operator=(const Ref &p_from) {
@@ -99,7 +99,7 @@ public:
 		}
 		Ref r;
 		//r.reference = Object::cast_to<T>(refb);
-		r.reference = (T*)refb;
+		r.reference = (T *)refb;
 		ref(r);
 		r.reference = nullptr;
 	}
@@ -107,7 +107,7 @@ public:
 	void operator=(const Variant &p_variant) {
 
 		// TODO We need a safe cast
-		Reference *refb = (Reference *) (Object *) p_variant;
+		Reference *refb = (Reference *)T::___get_from_variant(p_variant);
 		if (!refb) {
 			unref();
 			return;
@@ -156,7 +156,7 @@ public:
 
 		reference = nullptr;
 		// TODO We need a safe cast
-		Reference *refb = (Reference *) (Object *) p_variant;
+		Reference *refb = (Reference *)T::___get_from_variant(p_variant);
 		if (!refb) {
 			unref();
 			return;
@@ -180,14 +180,14 @@ public:
 		if (reference && reference->unreference()) {
 
 			//memdelete(reference);
-			delete reference;
+			reference->free();
 		}
 		reference = nullptr;
 	}
 
 	void instance() {
 		//ref(memnew(T));
-		ref(new T);
+		ref(T::_new());
 	}
 
 	Ref() {
@@ -202,14 +202,13 @@ public:
 
 	// Used exclusively in the bindings to recreate the Ref Godot encapsulates in return values,
 	// without adding to the refcount.
-	inline static Ref<T> __internal_constructor(Object *obj)
-	{
+	inline static Ref<T> __internal_constructor(Object *obj) {
 		Ref<T> r;
-		r.reference = (T*)obj;
+		r.reference = (T *)obj;
 		return r;
 	}
 };
 
-}
+} // namespace godot
 
 #endif

include/core/String.hpp

@@ -8,6 +8,7 @@ namespace godot {
 class NodePath;
 class Variant;
 class PoolByteArray;
+class PoolIntArray;
 class PoolRealArray;
 class PoolStringArray;
 class String;
@@ -67,8 +68,6 @@ public:
 	CharString utf8() const;
 	CharString ascii(bool p_extended = false) const;
 
-	int64_t find(String p_what) const;
-	int64_t find_from(String p_what, int64_t p_from) const;
 	bool begins_with(String &s) const;
 	bool begins_with_char_array(const char *p_char_array) const;
 	PoolStringArray bigrams() const;
@@ -120,6 +119,7 @@ public:
 	String sha256_text() const;
 	float similarity(String text) const;
 	PoolStringArray split(String divisor, bool allow_empty = true) const;
+	PoolIntArray split_ints(String divisor, bool allow_empty = true) const;
 	PoolRealArray split_floats(String divisor, bool allow_empty = true) const;
 	String strip_edges(bool left = true, bool right = true) const;
 	String substr(int from, int len) const;
@@ -129,12 +129,14 @@ public:
 	String to_upper() const;
 	String xml_escape() const;
 	String xml_unescape() const;
-
+	signed char casecmp_to(String p_str) const;
+	signed char nocasecmp_to(String p_str) const;
+	signed char naturalnocasecmp_to(String p_str) const;
 };
 
 String operator+(const char *a, const String &b);
 String operator+(const wchar_t *a, const String &b);
 
-}
+} // namespace godot
 
 #endif // STRING_H

include/core/TagDB.hpp

@@ -0,0 +1,19 @@
+#ifndef TAGDB_HPP
+#define TAGDB_HPP
+
+#include <stddef.h>
+
+namespace godot {
+
+namespace _TagDB {
+
+void register_type(size_t type_tag, size_t base_type_tag);
+bool is_type_known(size_t type_tag);
+void register_global_type(const char *name, size_t type_tag, size_t base_type_tag);
+bool is_type_compatible(size_t type_tag, size_t base_type_tag);
+
+} // namespace _TagDB
+
+} // namespace godot
+
+#endif // TAGDB_HPP

include/core/Transform.hpp

@@ -3,14 +3,13 @@
 
 #include "Basis.hpp"
 
-#include "Plane.hpp"
 #include "AABB.hpp"
+#include "Plane.hpp"
 
 namespace godot {
 
 class Transform {
 public:
-
 	Basis basis;
 	Vector3 origin;
 
@@ -20,62 +19,61 @@ public:
 	void affine_invert();
 	Transform affine_inverse() const;
 
-	Transform rotated(const Vector3& p_axis,real_t p_phi) const;
+	Transform rotated(const Vector3 &p_axis, real_t p_phi) const;
 
-	void rotate(const Vector3& p_axis,real_t p_phi);
-	void rotate_basis(const Vector3& p_axis,real_t p_phi);
+	void rotate(const Vector3 &p_axis, real_t p_phi);
+	void rotate_basis(const Vector3 &p_axis, real_t p_phi);
 
-	void set_look_at( const Vector3& p_eye, const Vector3& p_target, const Vector3& p_up );
-	Transform looking_at( const Vector3& p_target, const Vector3& p_up ) const;
+	void set_look_at(const Vector3 &p_eye, const Vector3 &p_target, const Vector3 &p_up);
+	Transform looking_at(const Vector3 &p_target, const Vector3 &p_up) const;
 
-	void scale(const Vector3& p_scale);
-	Transform scaled(const Vector3& p_scale) const;
-	void scale_basis(const Vector3& p_scale);
-	void translate( real_t p_tx, real_t p_ty, real_t p_tz );
-	void translate( const Vector3& p_translation );
-	Transform translated( const Vector3& p_translation ) const;
+	void scale(const Vector3 &p_scale);
+	Transform scaled(const Vector3 &p_scale) const;
+	void scale_basis(const Vector3 &p_scale);
+	void translate(real_t p_tx, real_t p_ty, real_t p_tz);
+	void translate(const Vector3 &p_translation);
+	Transform translated(const Vector3 &p_translation) const;
 
-	inline const Basis& get_basis() const { return basis; }
-	inline void set_basis(const Basis& p_basis) { basis=p_basis; }
+	inline const Basis &get_basis() const { return basis; }
+	inline void set_basis(const Basis &p_basis) { basis = p_basis; }
 
-	inline const Vector3& get_origin() const { return origin; }
-	inline void set_origin(const Vector3& p_origin) { origin=p_origin; }
+	inline const Vector3 &get_origin() const { return origin; }
+	inline void set_origin(const Vector3 &p_origin) { origin = p_origin; }
 
 	void orthonormalize();
 	Transform orthonormalized() const;
 
-	bool operator==(const Transform& p_transform) const;
-	bool operator!=(const Transform& p_transform) const;
+	bool operator==(const Transform &p_transform) const;
+	bool operator!=(const Transform &p_transform) const;
 
-	Vector3 xform(const Vector3& p_vector) const;
-	Vector3 xform_inv(const Vector3& p_vector) const;
+	Vector3 xform(const Vector3 &p_vector) const;
+	Vector3 xform_inv(const Vector3 &p_vector) const;
 
-	Plane xform(const Plane& p_plane) const;
-	Plane xform_inv(const Plane& p_plane) const;
+	Plane xform(const Plane &p_plane) const;
+	Plane xform_inv(const Plane &p_plane) const;
 
-	AABB xform(const AABB& p_aabb) const;
-	AABB xform_inv(const AABB& p_aabb) const;
+	AABB xform(const AABB &p_aabb) const;
+	AABB xform_inv(const AABB &p_aabb) const;
 
-	void operator*=(const Transform& p_transform);
-	Transform operator*(const Transform& p_transform) const;
+	void operator*=(const Transform &p_transform);
+	Transform operator*(const Transform &p_transform) const;
 
-	Transform interpolate_with(const Transform& p_transform, real_t p_c) const;
+	Transform interpolate_with(const Transform &p_transform, real_t p_c) const;
 
-	Transform inverse_xform(const Transform& t) const;
+	Transform inverse_xform(const Transform &t) const;
 
-	void set(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz,real_t tx, real_t ty, real_t tz);
+	void set(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz, real_t tx, real_t ty, real_t tz);
 
 	operator String() const;
 
-	inline Transform(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz,real_t tx, real_t ty, real_t tz) {
-		set(xx, xy, xz, yx, yy, yz, zx, zy, zz,tx, ty, tz);
+	inline Transform(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz, real_t tx, real_t ty, real_t tz) {
+		set(xx, xy, xz, yx, yy, yz, zx, zy, zz, tx, ty, tz);
 	}
 
-	Transform(const Basis& p_basis, const Vector3& p_origin=Vector3());
+	Transform(const Basis &p_basis, const Vector3 &p_origin = Vector3());
 	inline Transform() {}
-
 };
 
-}
+} // namespace godot
 
 #endif // TRANSFORM_H

include/core/Transform2D.hpp

@@ -3,7 +3,6 @@
 
 #include "Vector2.hpp"
 
-
 namespace godot {
 
 typedef Vector2 Size2;
@@ -24,14 +23,20 @@ struct Transform2D {
 
 	Vector2 elements[3];
 
-	inline real_t tdotx(const Vector2& v) const { return elements[0][0] * v.x + elements[1][0] * v.y; }
-	inline real_t tdoty(const Vector2& v) const { return elements[0][1] * v.x + elements[1][1] * v.y; }
+	inline real_t tdotx(const Vector2 &v) const { return elements[0][0] * v.x + elements[1][0] * v.y; }
+	inline real_t tdoty(const Vector2 &v) const { return elements[0][1] * v.x + elements[1][1] * v.y; }
 
-	inline const Vector2& operator[](int p_idx) const { return elements[p_idx]; }
-	inline Vector2& operator[](int p_idx) { return elements[p_idx]; }
+	inline const Vector2 &operator[](int p_idx) const { return elements[p_idx]; }
+	inline Vector2 &operator[](int p_idx) { return elements[p_idx]; }
 
-	inline Vector2 get_axis(int p_axis) const { ERR_FAIL_INDEX_V(p_axis,3,Vector2()); return elements[p_axis]; }
-	inline void set_axis(int p_axis,const Vector2& p_vec) { ERR_FAIL_INDEX(p_axis,3); elements[p_axis]=p_vec; }
+	inline Vector2 get_axis(int p_axis) const {
+		ERR_FAIL_INDEX_V(p_axis, 3, Vector2());
+		return elements[p_axis];
+	}
+	inline void set_axis(int p_axis, const Vector2 &p_vec) {
+		ERR_FAIL_INDEX(p_axis, 3);
+		elements[p_axis] = p_vec;
+	}
 
 	void invert();
 	Transform2D inverse() const;
@@ -41,24 +46,24 @@ struct Transform2D {
 
 	void set_rotation(real_t p_phi);
 	real_t get_rotation() const;
-	void set_rotation_and_scale(real_t p_phi,const Size2& p_scale);
+	void set_rotation_and_scale(real_t p_phi, const Size2 &p_scale);
 	void rotate(real_t p_phi);
 
-	void scale(const Size2& p_scale);
-	void scale_basis(const Size2& p_scale);
-	void translate( real_t p_tx, real_t p_ty);
-	void translate( const Vector2& p_translation );
+	void scale(const Size2 &p_scale);
+	void scale_basis(const Size2 &p_scale);
+	void translate(real_t p_tx, real_t p_ty);
+	void translate(const Vector2 &p_translation);
 
 	real_t basis_determinant() const;
 
 	Size2 get_scale() const;
 
-	inline const Vector2& get_origin() const { return elements[2]; }
-	inline void set_origin(const Vector2& p_origin) { elements[2]=p_origin; }
+	inline const Vector2 &get_origin() const { return elements[2]; }
+	inline void set_origin(const Vector2 &p_origin) { elements[2] = p_origin; }
 
-	Transform2D scaled(const Size2& p_scale) const;
-	Transform2D basis_scaled(const Size2& p_scale) const;
-	Transform2D translated(const Vector2& p_offset) const;
+	Transform2D scaled(const Size2 &p_scale) const;
+	Transform2D basis_scaled(const Size2 &p_scale) const;
+	Transform2D translated(const Vector2 &p_offset) const;
 	Transform2D rotated(real_t p_phi) const;
 
 	Transform2D untranslated() const;
@@ -66,29 +71,32 @@ struct Transform2D {
 	void orthonormalize();
 	Transform2D orthonormalized() const;
 
-	bool operator==(const Transform2D& p_transform) const;
-	bool operator!=(const Transform2D& p_transform) const;
+	bool operator==(const Transform2D &p_transform) const;
+	bool operator!=(const Transform2D &p_transform) const;
 
-	void operator*=(const Transform2D& p_transform);
-	Transform2D operator*(const Transform2D& p_transform) const;
+	void operator*=(const Transform2D &p_transform);
+	Transform2D operator*(const Transform2D &p_transform) const;
 
-	Transform2D interpolate_with(const Transform2D& p_transform, real_t p_c) const;
+	Transform2D interpolate_with(const Transform2D &p_transform, real_t p_c) const;
 
-	Vector2 basis_xform(const Vector2& p_vec) const;
-	Vector2 basis_xform_inv(const Vector2& p_vec) const;
-	Vector2 xform(const Vector2& p_vec) const;
-	Vector2 xform_inv(const Vector2& p_vec) const;
-	Rect2 xform(const Rect2& p_vec) const;
-	Rect2 xform_inv(const Rect2& p_vec) const;
+	Vector2 basis_xform(const Vector2 &p_vec) const;
+	Vector2 basis_xform_inv(const Vector2 &p_vec) const;
+	Vector2 xform(const Vector2 &p_vec) const;
+	Vector2 xform_inv(const Vector2 &p_vec) const;
+	Rect2 xform(const Rect2 &p_vec) const;
+	Rect2 xform_inv(const Rect2 &p_vec) const;
 
 	operator String() const;
 
 	Transform2D(real_t xx, real_t xy, real_t yx, real_t yy, real_t ox, real_t oy);
 
-	Transform2D(real_t p_rot, const Vector2& p_pos);
-	inline Transform2D() { elements[0][0]=1.0; elements[1][1]=1.0; }
+	Transform2D(real_t p_rot, const Vector2 &p_pos);
+	inline Transform2D() {
+		elements[0][0] = 1.0;
+		elements[1][1] = 1.0;
+	}
 };
 
-}
+} // namespace godot
 
 #endif // TRANSFORM2D_H

include/core/Variant.hpp

@@ -12,8 +12,8 @@
 #include "Plane.hpp"
 #include "PoolArrays.hpp"
 #include "Quat.hpp"
-#include "Rect2.hpp"
 #include "RID.hpp"
+#include "Rect2.hpp"
 #include "String.hpp"
 #include "Transform.hpp"
 #include "Transform2D.hpp"
@@ -30,6 +30,7 @@ class Array;
 
 class Variant {
 	godot_variant _godot_variant;
+
 public:
 	enum Type {
 
@@ -43,31 +44,31 @@ public:
 
 		// math types
 
-		VECTOR2,		// 5
+		VECTOR2, // 5
 		RECT2,
 		VECTOR3,
 		TRANSFORM2D,
 		PLANE,
-		QUAT,			// 10
+		QUAT, // 10
 		RECT3, //sorry naming convention fail :( not like it's used often
 		BASIS,
 		TRANSFORM,
 
 		// misc types
 		COLOR,
-		NODE_PATH,              // 15
+		NODE_PATH, // 15
 		_RID,
 		OBJECT,
 		DICTIONARY,
 		ARRAY,
 
 		// arrays
-		POOL_BYTE_ARRAY,        // 20
+		POOL_BYTE_ARRAY, // 20
 		POOL_INT_ARRAY,
 		POOL_REAL_ARRAY,
 		POOL_STRING_ARRAY,
 		POOL_VECTOR2_ARRAY,
-		POOL_VECTOR3_ARRAY,     // 25
+		POOL_VECTOR3_ARRAY, // 25
 		POOL_COLOR_ARRAY,
 
 		VARIANT_MAX
@@ -116,7 +117,7 @@ public:
 
 	Variant();
 
-	Variant(const Variant& v);
+	Variant(const Variant &v);
 
 	Variant(bool p_bool);
 
@@ -126,11 +127,14 @@ public:
 
 	Variant(signed short p_short);
 
-	inline Variant(unsigned short p_short) : Variant((unsigned int) p_short) {}
+	inline Variant(unsigned short p_short) :
+			Variant((unsigned int)p_short) {}
 
-	inline Variant(signed char p_char) : Variant((signed int) p_char) {}
+	inline Variant(signed char p_char) :
+			Variant((signed int)p_char) {}
 
-	inline Variant(unsigned char p_char) : Variant((unsigned int) p_char) {}
+	inline Variant(unsigned char p_char) :
+			Variant((unsigned int)p_char) {}
 	Variant(int64_t p_char);
 
 	Variant(uint64_t p_char);
@@ -139,64 +143,61 @@ public:
 
 	Variant(double p_double);
 
-	Variant(const String& p_string);
+	Variant(const String &p_string);
 
-	Variant(const char * const p_cstring);
+	Variant(const char *const p_cstring);
 
-	Variant(const wchar_t * p_wstring);
+	Variant(const wchar_t *p_wstring);
 
-	Variant(const Vector2& p_vector2);
+	Variant(const Vector2 &p_vector2);
 
-	Variant(const Rect2& p_rect2);
+	Variant(const Rect2 &p_rect2);
 
-	Variant(const Vector3& p_vector3);
+	Variant(const Vector3 &p_vector3);
 
-	Variant(const Plane& p_plane);
+	Variant(const Plane &p_plane);
 
+	Variant(const AABB &p_aabb);
 
-	Variant(const AABB& p_aabb);
+	Variant(const Quat &p_quat);
 
-	Variant(const Quat& p_quat);
+	Variant(const Basis &p_transform);
 
-	Variant(const Basis& p_transform);
+	Variant(const Transform2D &p_transform);
 
-	Variant(const Transform2D& p_transform);
+	Variant(const Transform &p_transform);
 
-	Variant(const Transform& p_transform);
+	Variant(const Color &p_color);
 
-	Variant(const Color& p_color);
+	Variant(const NodePath &p_path);
 
-	Variant(const NodePath& p_path);
+	Variant(const RID &p_rid);
 
-	Variant(const RID& p_rid);
+	Variant(const Object *p_object);
 
-	Variant(const Object* p_object);
+	Variant(const Dictionary &p_dictionary);
 
-	Variant(const Dictionary& p_dictionary);
+	Variant(const Array &p_array);
 
-	Variant(const Array& p_array);
+	Variant(const PoolByteArray &p_raw_array);
 
-	Variant(const PoolByteArray& p_raw_array);
+	Variant(const PoolIntArray &p_int_array);
 
-	Variant(const PoolIntArray& p_int_array);
+	Variant(const PoolRealArray &p_real_array);
 
-	Variant(const PoolRealArray& p_real_array);
+	Variant(const PoolStringArray &p_string_array);
 
-	Variant(const PoolStringArray& p_string_array);
+	Variant(const PoolVector2Array &p_vector2_array);
 
-	Variant(const PoolVector2Array& p_vector2_array);
+	Variant(const PoolVector3Array &p_vector3_array);
 
-	Variant(const PoolVector3Array& p_vector3_array);
-
-	Variant(const PoolColorArray& p_color_array);
-
-
-	Variant &operator =(const Variant& v);
+	Variant(const PoolColorArray &p_color_array);
 
+	Variant &operator=(const Variant &v);
 
 	operator bool() const;
 	operator signed int() const;
-	operator unsigned int() const ;
+	operator unsigned int() const;
 	operator signed short() const;
 	operator unsigned short() const;
 	operator signed char() const;
@@ -204,7 +205,6 @@ public:
 	operator int64_t() const;
 	operator uint64_t() const;
 
-
 	operator wchar_t() const;
 
 	operator float() const;
@@ -225,7 +225,7 @@ public:
 
 	operator NodePath() const;
 	operator RID() const;
-	operator Object*() const;
+	operator godot_object *() const;
 
 	operator Dictionary() const;
 	operator Array() const;
@@ -240,32 +240,29 @@ public:
 
 	Type get_type() const;
 
+	Variant call(const String &method, const Variant **args, const int arg_count);
 
-	Variant call(const String& method, const Variant **args, const int arg_count);
+	bool has_method(const String &method);
 
-	bool has_method(const String& method);
+	bool operator==(const Variant &b) const;
 
-	bool operator ==(const Variant& b) const;
+	bool operator!=(const Variant &b) const;
 
-	bool operator !=(const Variant& b) const;
+	bool operator<(const Variant &b) const;
 
-	bool operator <(const Variant& b) const;
+	bool operator<=(const Variant &b) const;
 
-	bool operator <=(const Variant& b) const;
+	bool operator>(const Variant &b) const;
 
-	bool operator >(const Variant& b) const;
+	bool operator>=(const Variant &b) const;
 
-	bool operator >=(const Variant& b) const;
-
-	bool hash_compare(const Variant& b) const;
+	bool hash_compare(const Variant &b) const;
 
 	bool booleanize() const;
 
 	~Variant();
-
-
 };
 
-}
+} // namespace godot
 
 #endif // VARIANT_H

include/core/Vector2.hpp

@@ -20,21 +20,20 @@ struct Vector2 {
 		real_t height;
 	};
 
-
-	inline real_t& operator[](int p_idx) {
-		return p_idx?y:x;
+	inline real_t &operator[](int p_idx) {
+		return p_idx ? y : x;
 	}
-	inline const real_t& operator[](int p_idx) const {
-		return p_idx?y:x;
+	inline const real_t &operator[](int p_idx) const {
+		return p_idx ? y : x;
 	}
 
-	Vector2 operator+(const Vector2& p_v) const;
+	Vector2 operator+(const Vector2 &p_v) const;
 
-	void operator+=(const Vector2& p_v);
+	void operator+=(const Vector2 &p_v);
 
-	Vector2 operator-(const Vector2& p_v) const;
+	Vector2 operator-(const Vector2 &p_v) const;
 
-	void operator-=(const Vector2& p_v);
+	void operator-=(const Vector2 &p_v);
 
 	Vector2 operator*(const Vector2 &p_v1) const;
 
@@ -52,13 +51,12 @@ struct Vector2 {
 
 	Vector2 operator-() const;
 
-	bool operator==(const Vector2& p_vec2) const;
+	bool operator==(const Vector2 &p_vec2) const;
 
-	bool operator!=(const Vector2& p_vec2) const;
-
-	inline bool operator<(const Vector2& p_vec2) const { return (x==p_vec2.x)?(y<p_vec2.y):(x<p_vec2.x); }
-	inline bool operator<=(const Vector2& p_vec2) const { return (x==p_vec2.x)?(y<=p_vec2.y):(x<=p_vec2.x); }
+	bool operator!=(const Vector2 &p_vec2) const;
 
+	inline bool operator<(const Vector2 &p_vec2) const { return (x == p_vec2.x) ? (y < p_vec2.y) : (x < p_vec2.x); }
+	inline bool operator<=(const Vector2 &p_vec2) const { return (x == p_vec2.x) ? (y <= p_vec2.y) : (x <= p_vec2.x); }
 
 	void normalize();
 
@@ -67,32 +65,31 @@ struct Vector2 {
 	real_t length() const;
 	real_t length_squared() const;
 
-	real_t distance_to(const Vector2& p_vector2) const;
-	real_t distance_squared_to(const Vector2& p_vector2) const;
+	real_t distance_to(const Vector2 &p_vector2) const;
+	real_t distance_squared_to(const Vector2 &p_vector2) const;
 
-	real_t angle_to(const Vector2& p_vector2) const;
-	real_t angle_to_point(const Vector2& p_vector2) const;
+	real_t angle_to(const Vector2 &p_vector2) const;
+	real_t angle_to_point(const Vector2 &p_vector2) const;
 
-	real_t dot(const Vector2& p_other) const;
+	real_t dot(const Vector2 &p_other) const;
 
-	real_t cross(const Vector2& p_other) const;
+	real_t cross(const Vector2 &p_other) const;
 	Vector2 cross(real_t p_other) const;
 
-	Vector2 project(const Vector2& p_vec) const;
+	Vector2 project(const Vector2 &p_vec) const;
 
-	Vector2 plane_project(real_t p_d, const Vector2& p_vec) const;
+	Vector2 plane_project(real_t p_d, const Vector2 &p_vec) const;
 
 	Vector2 clamped(real_t p_len) const;
 
-	static Vector2 linear_interpolate(const Vector2& p_a, const Vector2& p_b,real_t p_t);
+	static Vector2 linear_interpolate(const Vector2 &p_a, const Vector2 &p_b, real_t p_t);
 
-	Vector2 linear_interpolate(const Vector2& p_b,real_t p_t) const;
-	Vector2 cubic_interpolate(const Vector2& p_b,const Vector2& p_pre_a, const Vector2& p_post_b,real_t p_t) const;
+	Vector2 linear_interpolate(const Vector2 &p_b, real_t p_t) const;
+	Vector2 cubic_interpolate(const Vector2 &p_b, const Vector2 &p_pre_a, const Vector2 &p_post_b, real_t p_t) const;
 
+	Vector2 slide(const Vector2 &p_vec) const;
 
-	Vector2 slide(const Vector2& p_vec) const;
-
-	Vector2 reflect(const Vector2& p_vec) const;
+	Vector2 reflect(const Vector2 &p_vec) const;
 
 	real_t angle() const;
 
@@ -105,24 +102,25 @@ struct Vector2 {
 
 	Vector2 floor() const;
 
-	Vector2 snapped(const Vector2& p_by) const;
-	inline real_t aspect() const { return width/height; }
-
+	Vector2 snapped(const Vector2 &p_by) const;
+	inline real_t aspect() const { return width / height; }
 
 	operator String() const;
 
-	inline Vector2(real_t p_x,real_t p_y) { x=p_x; y=p_y; }
-	inline Vector2() { x=0; y=0; }
+	inline Vector2(real_t p_x, real_t p_y) {
+		x = p_x;
+		y = p_y;
+	}
+	inline Vector2() {
+		x = 0;
+		y = 0;
+	}
 };
 
-
-inline Vector2 operator*(real_t p_scalar, const Vector2& p_vec)
-{
-	return p_vec*p_scalar;
+inline Vector2 operator*(real_t p_scalar, const Vector2 &p_vec) {
+	return p_vec * p_scalar;
 }
 
-
-
-}
+} // namespace godot
 
 #endif // VECTOR2_H

include/core/Vector3.hpp

@@ -7,6 +7,7 @@
 
 namespace godot {
 
+class Basis;
 
 struct Vector3 {
 
@@ -30,71 +31,75 @@ struct Vector3 {
 
 	Vector3();
 
-	const real_t& operator[](int p_axis) const;
+	const real_t &operator[](int p_axis) const;
 
-	real_t& operator[](int p_axis);
+	real_t &operator[](int p_axis);
 
-	Vector3& operator+=(const Vector3& p_v);
+	Vector3 &operator+=(const Vector3 &p_v);
 
-	Vector3 operator+(const Vector3& p_v) const;
+	Vector3 operator+(const Vector3 &p_v) const;
 
-	Vector3& operator-=(const Vector3& p_v);
+	Vector3 &operator-=(const Vector3 &p_v);
 
-	Vector3 operator-(const Vector3& p_v) const;
+	Vector3 operator-(const Vector3 &p_v) const;
 
-	Vector3& operator*=(const Vector3& p_v);
+	Vector3 &operator*=(const Vector3 &p_v);
 
-	Vector3 operator*(const Vector3& p_v) const;
+	Vector3 operator*(const Vector3 &p_v) const;
 
-	Vector3& operator/=(const Vector3& p_v);
+	Vector3 &operator/=(const Vector3 &p_v);
 
-	Vector3 operator/(const Vector3& p_v) const;
+	Vector3 operator/(const Vector3 &p_v) const;
 
-
-	Vector3& operator*=(real_t p_scalar);
+	Vector3 &operator*=(real_t p_scalar);
 
 	Vector3 operator*(real_t p_scalar) const;
 
-	Vector3& operator/=(real_t p_scalar);
+	Vector3 &operator/=(real_t p_scalar);
 
 	Vector3 operator/(real_t p_scalar) const;
 
 	Vector3 operator-() const;
 
-	bool operator==(const Vector3& p_v) const;
+	bool operator==(const Vector3 &p_v) const;
 
-	bool operator!=(const Vector3& p_v) const;
+	bool operator!=(const Vector3 &p_v) const;
 
-	bool operator<(const Vector3& p_v) const;
+	bool operator<(const Vector3 &p_v) const;
 
-	bool operator<=(const Vector3& p_v) const;
+	bool operator<=(const Vector3 &p_v) const;
 
 	Vector3 abs() const;
 
 	Vector3 ceil() const;
 
-	Vector3 cross(const Vector3& b) const;
+	Vector3 cross(const Vector3 &b) const;
 
-	Vector3 linear_interpolate(const Vector3& p_b,real_t p_t) const;
+	Vector3 linear_interpolate(const Vector3 &p_b, real_t p_t) const;
 
-	Vector3 cubic_interpolate(const Vector3& b, const Vector3& pre_a, const Vector3& post_b, const real_t t) const;
+	Vector3 cubic_interpolate(const Vector3 &b, const Vector3 &pre_a, const Vector3 &post_b, const real_t t) const;
+
+	Vector3 bounce(const Vector3 &p_normal) const;
 
 	real_t length() const;
 
 	real_t length_squared() const;
 
-	real_t distance_squared_to(const Vector3& b) const;
+	real_t distance_squared_to(const Vector3 &b) const;
 
-	real_t distance_to(const Vector3& b) const;
+	real_t distance_to(const Vector3 &b) const;
 
-	real_t dot(const Vector3& b) const;
+	real_t dot(const Vector3 &b) const;
+
+	real_t angle_to(const Vector3 &b) const;
 
 	Vector3 floor() const;
 
 	Vector3 inverse() const;
 
+	bool is_normalized() const;
 
-
+	Basis outer(const Vector3 &b) const;
 
 	int max_axis() const;
 
@@ -104,13 +109,13 @@ struct Vector3 {
 
 	Vector3 normalized() const;
 
-	Vector3 reflect(const Vector3& by) const;
+	Vector3 reflect(const Vector3 &by) const;
 
-	Vector3 rotated(const Vector3& axis, const real_t phi) const;
+	Vector3 rotated(const Vector3 &axis, const real_t phi) const;
 
-	void rotate(const Vector3& p_axis,real_t p_phi);
+	void rotate(const Vector3 &p_axis, real_t p_phi);
 
-	Vector3 slide(const Vector3& by) const;
+	Vector3 slide(const Vector3 &by) const;
 
 	void snap(real_t p_val);
 
@@ -119,16 +124,15 @@ struct Vector3 {
 	operator String() const;
 };
 
-inline Vector3 operator*(real_t p_scalar, const Vector3& p_vec)
-{
+inline Vector3 operator*(real_t p_scalar, const Vector3 &p_vec) {
 	return p_vec * p_scalar;
 }
 
-inline Vector3 vec3_cross(const Vector3& p_a, const Vector3& p_b) {
+inline Vector3 vec3_cross(const Vector3 &p_a, const Vector3 &p_b) {
 
 	return p_a.cross(p_b);
 }
 
-}
+} // namespace godot
 
 #endif // VECTOR3_H

include/core/Wrapped.hpp

@@ -0,0 +1,16 @@
+#ifndef WRAPPED_HPP
+#define WRAPPED_HPP
+
+#include <gdnative/gdnative.h>
+
+namespace godot {
+
+class _Wrapped {
+public:
+	godot_object *_owner;
+	size_t _type_tag;
+};
+
+} // namespace godot
+
+#endif // WRAPPED_HPP

include/gen/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore

misc/hooks/README.md

@@ -0,0 +1,18 @@
+# Git hooks for Godot Engine
+
+This folder contains git hooks meant to be installed locally by Godot Engine
+contributors to make sure they comply with our requirements.
+
+## List of hooks
+
+- Pre-commit hook for clang-format: Applies clang-format to the staged files
+  before accepting a commit; blocks the commit and generates a patch if the
+  style is not respected.
+  Should work on Linux and macOS. You may need to edit the file if your
+  clang-format binary is not in the $PATH, or if you want to enable colored
+  output with pygmentize.
+
+## Installation
+
+Copy all the files from this folder into your .git/hooks folder, and make sure
+the hooks and helper scripts are executable.

misc/hooks/canonicalize_filename.sh

@@ -0,0 +1,48 @@
+#!/bin/sh
+
+# Provide the canonicalize filename (physical filename with out any symlinks)
+# like the GNU version readlink with the -f option regardless of the version of
+# readlink (GNU or BSD).
+
+# This file is part of a set of unofficial pre-commit hooks available
+# at github.
+# Link:    https://github.com/githubbrowser/Pre-commit-hooks
+# Contact: David Martin, david.martin.mailbox@googlemail.com
+
+###########################################################
+# There should be no need to change anything below this line.
+
+# Canonicalize by recursively following every symlink in every component of the
+# specified filename.  This should reproduce the results of the GNU version of
+# readlink with the -f option.
+#
+# Reference: http://stackoverflow.com/questions/1055671/how-can-i-get-the-behavior-of-gnus-readlink-f-on-a-mac
+canonicalize_filename () {
+    local target_file="$1"
+    local physical_directory=""
+    local result=""
+
+    # Need to restore the working directory after work.
+    local working_dir="`pwd`"
+
+    cd -- "$(dirname -- "$target_file")"
+    target_file="$(basename -- "$target_file")"
+
+    # Iterate down a (possible) chain of symlinks
+    while [ -L "$target_file" ]
+    do
+        target_file="$(readlink -- "$target_file")"
+        cd -- "$(dirname -- "$target_file")"
+        target_file="$(basename -- "$target_file")"
+    done
+
+    # Compute the canonicalized name by finding the physical path
+    # for the directory we're in and appending the target file.
+    physical_directory="`pwd -P`"
+    result="$physical_directory/$target_file"
+
+    # restore the working directory after work.
+    cd -- "$working_dir"
+
+    echo "$result"
+}

misc/hooks/pre-commit

@@ -0,0 +1,50 @@
+#!/bin/sh
+# Git pre-commit hook that runs multiple hooks specified in $HOOKS.
+# Make sure this script is executable. Bypass hooks with git commit --no-verify.
+
+# This file is part of a set of unofficial pre-commit hooks available
+# at github.
+# Link:    https://github.com/githubbrowser/Pre-commit-hooks
+# Contact: David Martin, david.martin.mailbox@googlemail.com
+
+
+###########################################################
+# CONFIGURATION:
+# pre-commit hooks to be executed. They should be in the same .git/hooks/ folder
+# as this script. Hooks should return 0 if successful and nonzero to cancel the
+# commit. They are executed in the order in which they are listed.
+#HOOKS="pre-commit-compile pre-commit-uncrustify"
+HOOKS="pre-commit-clang-format"
+###########################################################
+# There should be no need to change anything below this line.
+
+. "$(dirname -- "$0")/canonicalize_filename.sh"
+
+# exit on error
+set -e
+
+# Absolute path to this script, e.g. /home/user/bin/foo.sh
+SCRIPT="$(canonicalize_filename "$0")"
+
+# Absolute path this script is in, thus /home/user/bin
+SCRIPTPATH="$(dirname -- "$SCRIPT")"
+
+
+for hook in $HOOKS
+do
+    echo "Running hook: $hook"
+    # run hook if it exists
+    # if it returns with nonzero exit with 1 and thus abort the commit
+    if [ -f "$SCRIPTPATH/$hook" ]; then
+        "$SCRIPTPATH/$hook"
+        if [ $? != 0 ]; then
+            exit 1
+        fi
+    else
+        echo "Error: file $hook not found."
+        echo "Aborting commit. Make sure the hook is in $SCRIPTPATH and executable."
+        echo "You can disable it by removing it from the list in $SCRIPT."
+        echo "You can skip all pre-commit hooks with --no-verify (not recommended)."
+        exit 1
+    fi
+done

misc/hooks/pre-commit-clang-format

@@ -0,0 +1,147 @@
+#!/usr/bin/env bash
+
+# git pre-commit hook that runs a clang-format stylecheck.
+# Features:
+#  - abort commit when commit does not comply with the style guidelines
+#  - create a patch of the proposed style changes
+# Modifications for clang-format by rene.milk@wwu.de
+
+# This file is part of a set of unofficial pre-commit hooks available
+# at github.
+# Link:    https://github.com/githubbrowser/Pre-commit-hooks
+# Contact: David Martin, david.martin.mailbox@googlemail.com
+
+# Some quality of life modifications made for Godot Engine.
+
+##################################################################
+# SETTINGS
+# Set path to clang-format binary
+# CLANG_FORMAT="/usr/bin/clang-format"
+CLANG_FORMAT=`which clang-format`
+
+# Remove any older patches from previous commits. Set to true or false.
+# DELETE_OLD_PATCHES=false
+DELETE_OLD_PATCHES=false
+
+# Only parse files with the extensions in FILE_EXTS. Set to true or false.
+# If false every changed file in the commit will be parsed with clang-format.
+# If true only files matching one of the extensions are parsed with clang-format.
+# PARSE_EXTS=true
+PARSE_EXTS=true
+
+# File types to parse. Only effective when PARSE_EXTS is true.
+# FILE_EXTS=".c .h .cpp .hpp"
+FILE_EXTS=".c .h .cpp .hpp .cc .hh .cxx .m .mm .inc .java .glsl"
+
+# Use pygmentize instead of cat to parse diff with highlighting.
+# Install it with `pip install pygments` (Linux) or `easy_install Pygments` (Mac)
+# READER="pygmentize -l diff"
+READER=cat
+
+##################################################################
+# There should be no need to change anything below this line.
+
+. "$(dirname -- "$0")/canonicalize_filename.sh"
+
+# exit on error
+set -e
+
+# check whether the given file matches any of the set extensions
+matches_extension() {
+    local filename=$(basename "$1")
+    local extension=".${filename##*.}"
+    local ext
+
+    for ext in $FILE_EXTS; do [[ "$ext" == "$extension" ]] && return 0; done
+
+    return 1
+}
+
+# necessary check for initial commit
+if git rev-parse --verify HEAD >/dev/null 2>&1 ; then
+    against=HEAD
+else
+    # Initial commit: diff against an empty tree object
+    against=4b825dc642cb6eb9a060e54bf8d69288fbee4904
+fi
+
+if [ ! -x "$CLANG_FORMAT" ] ; then
+    printf "Error: clang-format executable not found.\n"
+    printf "Set the correct path in $(canonicalize_filename "$0").\n"
+    exit 1
+fi
+
+# create a random filename to store our generated patch
+prefix="pre-commit-clang-format"
+suffix="$(date +%s)"
+patch="/tmp/$prefix-$suffix.patch"
+
+# clean up any older clang-format patches
+$DELETE_OLD_PATCHES && rm -f /tmp/$prefix*.patch
+
+# create one patch containing all changes to the files
+git diff-index --cached --diff-filter=ACMR --name-only $against -- | while read file;
+do
+    # ignore thirdparty files
+    if grep -q "thirdparty" <<< $file; then
+        continue;
+    fi
+
+    # ignore file if we do check for file extensions and the file
+    # does not match any of the extensions specified in $FILE_EXTS
+    if $PARSE_EXTS && ! matches_extension "$file"; then
+        continue;
+    fi
+
+    # clang-format our sourcefile, create a patch with diff and append it to our $patch
+    # The sed call is necessary to transform the patch from
+    #    --- $file timestamp
+    #    +++ - timestamp
+    # to both lines working on the same file and having a/ and b/ prefix.
+    # Else it can not be applied with 'git apply'.
+    "$CLANG_FORMAT" -style=file "$file" | \
+        diff -u "$file" - | \
+        sed -e "1s|--- |--- a/|" -e "2s|+++ -|+++ b/$file|" >> "$patch"
+done
+
+# if no patch has been generated all is ok, clean up the file stub and exit
+if [ ! -s "$patch" ] ; then
+    printf "Files in this commit comply with the clang-format rules.\n"
+    rm -f "$patch"
+    exit 0
+fi
+
+# a patch has been created, notify the user and exit
+printf "\nThe following differences were found between the code to commit "
+printf "and the clang-format rules:\n\n"
+$READER "$patch"
+printf "\n"
+
+# Allows us to read user input below, assigns stdin to keyboard
+exec < /dev/tty
+
+while true; do
+    read -p "Do you want to apply that patch (Y - Apply, N - Do not apply, S - Apply and stage files)? [Y/N/S] " yn
+    case $yn in
+        [Yy] ) git apply $patch;
+        printf "The patch was applied. You can now stage the changes and commit again.\n\n";
+        break
+        ;;
+        [Nn] ) printf "\nYou can apply these changes with:\n  git apply $patch\n";
+        printf "(may need to be called from the root directory of your repository)\n";
+        printf "Aborting commit. Apply changes and commit again or skip checking with";
+        printf " --no-verify (not recommended).\n\n";
+        break
+        ;;
+        [Ss] ) git apply $patch;
+        git diff-index --cached --diff-filter=ACMR --name-only $against -- | while read file;
+        do git add $file;
+        done
+        printf "The patch was applied and the changed files staged. You can now commit.\n\n";
+        break
+        ;;
+        * ) echo "Please answer yes or no."
+        ;;
+    esac
+done
+exit 1 # we don't commit in any case

src/core/AABB.cpp

@@ -1,88 +1,86 @@
 #include "AABB.hpp"
-#include "Vector3.hpp"
 #include "Plane.hpp"
+#include "Vector3.hpp"
 
 #include <algorithm>
 
 namespace godot {
 
-bool AABB::intersects(const AABB& p_aabb) const {
+bool AABB::intersects(const AABB &p_aabb) const {
 
-	if ( position.x >= (p_aabb.position.x + p_aabb.size.x) )
+	if (position.x >= (p_aabb.position.x + p_aabb.size.x))
 		return false;
-	if ( (position.x+size.x) <= p_aabb.position.x  )
+	if ((position.x + size.x) <= p_aabb.position.x)
 		return false;
-	if ( position.y >= (p_aabb.position.y + p_aabb.size.y) )
+	if (position.y >= (p_aabb.position.y + p_aabb.size.y))
 		return false;
-	if ( (position.y+size.y) <= p_aabb.position.y  )
+	if ((position.y + size.y) <= p_aabb.position.y)
 		return false;
-	if ( position.z >= (p_aabb.position.z + p_aabb.size.z) )
+	if (position.z >= (p_aabb.position.z + p_aabb.size.z))
 		return false;
-	if ( (position.z+size.z) <= p_aabb.position.z  )
+	if ((position.z + size.z) <= p_aabb.position.z)
 		return false;
 
 	return true;
 }
 
-bool AABB::intersects_inclusive(const AABB& p_aabb) const {
+bool AABB::intersects_inclusive(const AABB &p_aabb) const {
 
-	if ( position.x > (p_aabb.position.x + p_aabb.size.x) )
+	if (position.x > (p_aabb.position.x + p_aabb.size.x))
 		return false;
-	if ( (position.x+size.x) < p_aabb.position.x  )
+	if ((position.x + size.x) < p_aabb.position.x)
 		return false;
-	if ( position.y > (p_aabb.position.y + p_aabb.size.y) )
+	if (position.y > (p_aabb.position.y + p_aabb.size.y))
 		return false;
-	if ( (position.y+size.y) < p_aabb.position.y  )
+	if ((position.y + size.y) < p_aabb.position.y)
 		return false;
-	if ( position.z > (p_aabb.position.z + p_aabb.size.z) )
+	if (position.z > (p_aabb.position.z + p_aabb.size.z))
 		return false;
-	if ( (position.z+size.z) < p_aabb.position.z  )
+	if ((position.z + size.z) < p_aabb.position.z)
 		return false;
 
 	return true;
 }
 
-bool AABB::encloses(const AABB & p_aabb) const {
+bool AABB::encloses(const AABB &p_aabb) const {
 
-	Vector3 src_min=position;
-	Vector3 src_max=position+size;
-	Vector3 dst_min=p_aabb.position;
-	Vector3 dst_max=p_aabb.position+p_aabb.size;
+	Vector3 src_min = position;
+	Vector3 src_max = position + size;
+	Vector3 dst_min = p_aabb.position;
+	Vector3 dst_max = p_aabb.position + p_aabb.size;
 
-	return  (
-		 (src_min.x <= dst_min.x) &&
+	return (
+			(src_min.x <= dst_min.x) &&
 			(src_max.x > dst_max.x) &&
 			(src_min.y <= dst_min.y) &&
 			(src_max.y > dst_max.y) &&
 			(src_min.z <= dst_min.z) &&
-			(src_max.z > dst_max.z) );
-
+			(src_max.z > dst_max.z));
 }
 
-Vector3 AABB::get_support(const Vector3& p_normal) const {
+Vector3 AABB::get_support(const Vector3 &p_normal) const {
 
 	Vector3 half_extents = size * 0.5;
 	Vector3 ofs = position + half_extents;
 
 	return Vector3(
-			(p_normal.x>0) ? -half_extents.x : half_extents.x,
-			(p_normal.y>0) ? -half_extents.y : half_extents.y,
-			(p_normal.z>0) ? -half_extents.z : half_extents.z
-		)+ofs;
+				   (p_normal.x > 0) ? -half_extents.x : half_extents.x,
+				   (p_normal.y > 0) ? -half_extents.y : half_extents.y,
+				   (p_normal.z > 0) ? -half_extents.z : half_extents.z) +
+		   ofs;
 }
 
-
 Vector3 AABB::get_endpoint(int p_point) const {
 
-	switch(p_point) {
-		case 0: return Vector3( position.x	, position.y		, position.z		);
-		case 1: return Vector3( position.x	, position.y		, position.z+size.z	);
-		case 2: return Vector3( position.x	, position.y+size.y	, position.z		);
-		case 3: return Vector3( position.x	, position.y+size.y	, position.z+size.z	);
-		case 4: return Vector3( position.x+size.x	, position.y		, position.z		);
-		case 5: return Vector3( position.x+size.x	, position.y		, position.z+size.z	);
-		case 6: return Vector3( position.x+size.x	, position.y+size.y	, position.z		);
-		case 7: return Vector3( position.x+size.x	, position.y+size.y	, position.z+size.z	);
+	switch (p_point) {
+		case 0: return Vector3(position.x, position.y, position.z);
+		case 1: return Vector3(position.x, position.y, position.z + size.z);
+		case 2: return Vector3(position.x, position.y + size.y, position.z);
+		case 3: return Vector3(position.x, position.y + size.y, position.z + size.z);
+		case 4: return Vector3(position.x + size.x, position.y, position.z);
+		case 5: return Vector3(position.x + size.x, position.y, position.z + size.z);
+		case 6: return Vector3(position.x + size.x, position.y + size.y, position.z);
+		case 7: return Vector3(position.x + size.x, position.y + size.y, position.z + size.z);
 	};
 
 	ERR_FAIL_V(Vector3());
@@ -93,14 +91,13 @@ bool AABB::intersects_convex_shape(const Plane *p_planes, int p_plane_count) con
 	Vector3 half_extents = size * 0.5;
 	Vector3 ofs = position + half_extents;
 
-	for(int i=0;i<p_plane_count;i++) {
-		const Plane &p=p_planes[i];
+	for (int i = 0; i < p_plane_count; i++) {
+		const Plane &p = p_planes[i];
 		Vector3 point(
-				(p.normal.x>0) ? -half_extents.x : half_extents.x,
-				(p.normal.y>0) ? -half_extents.y : half_extents.y,
-				(p.normal.z>0) ? -half_extents.z : half_extents.z
-			);
-		point+=ofs;
+				(p.normal.x > 0) ? -half_extents.x : half_extents.x,
+				(p.normal.y > 0) ? -half_extents.y : half_extents.y,
+				(p.normal.z > 0) ? -half_extents.z : half_extents.z);
+		point += ofs;
 		if (p.is_point_over(point))
 			return false;
 	}
@@ -108,69 +105,68 @@ bool AABB::intersects_convex_shape(const Plane *p_planes, int p_plane_count) con
 	return true;
 }
 
-bool AABB::has_point(const Vector3& p_point) const {
+bool AABB::has_point(const Vector3 &p_point) const {
 
-	if (p_point.x<position.x)
+	if (p_point.x < position.x)
 		return false;
-	if (p_point.y<position.y)
+	if (p_point.y < position.y)
 		return false;
-	if (p_point.z<position.z)
+	if (p_point.z < position.z)
 		return false;
-	if (p_point.x>position.x+size.x)
+	if (p_point.x > position.x + size.x)
 		return false;
-	if (p_point.y>position.y+size.y)
+	if (p_point.y > position.y + size.y)
 		return false;
-	if (p_point.z>position.z+size.z)
+	if (p_point.z > position.z + size.z)
 		return false;
 
 	return true;
 }
 
+void AABB::expand_to(const Vector3 &p_vector) {
 
-void AABB::expand_to(const Vector3& p_vector) {
+	Vector3 begin = position;
+	Vector3 end = position + size;
 
-	Vector3 begin=position;
-	Vector3 end=position+size;
+	if (p_vector.x < begin.x)
+		begin.x = p_vector.x;
+	if (p_vector.y < begin.y)
+		begin.y = p_vector.y;
+	if (p_vector.z < begin.z)
+		begin.z = p_vector.z;
 
-	if (p_vector.x<begin.x)
-		begin.x=p_vector.x;
-	if (p_vector.y<begin.y)
-		begin.y=p_vector.y;
-	if (p_vector.z<begin.z)
-		begin.z=p_vector.z;
+	if (p_vector.x > end.x)
+		end.x = p_vector.x;
+	if (p_vector.y > end.y)
+		end.y = p_vector.y;
+	if (p_vector.z > end.z)
+		end.z = p_vector.z;
 
-	if (p_vector.x>end.x)
-		end.x=p_vector.x;
-	if (p_vector.y>end.y)
-		end.y=p_vector.y;
-	if (p_vector.z>end.z)
-		end.z=p_vector.z;
-
-	position=begin;
-	size=end-begin;
+	position = begin;
+	size = end - begin;
 }
 
-void AABB::project_range_in_plane(const Plane& p_plane,real_t &r_min,real_t& r_max) const {
+void AABB::project_range_in_plane(const Plane &p_plane, real_t &r_min, real_t &r_max) const {
 
-	Vector3 half_extents( size.x * 0.5, size.y * 0.5, size.z * 0.5 );
-	Vector3 center( position.x + half_extents.x, position.y + half_extents.y, position.z + half_extents.z );
+	Vector3 half_extents(size.x * 0.5, size.y * 0.5, size.z * 0.5);
+	Vector3 center(position.x + half_extents.x, position.y + half_extents.y, position.z + half_extents.z);
 
 	real_t length = p_plane.normal.abs().dot(half_extents);
-	real_t distance = p_plane.distance_to( center );
+	real_t distance = p_plane.distance_to(center);
 	r_min = distance - length;
 	r_max = distance + length;
 }
 
 real_t AABB::get_longest_axis_size() const {
 
-	real_t max_size=size.x;
+	real_t max_size = size.x;
 
-	if (size.y > max_size ) {
-		max_size=size.y;
+	if (size.y > max_size) {
+		max_size = size.y;
 	}
 
-	if (size.z > max_size ) {
-		max_size=size.z;
+	if (size.z > max_size) {
+		max_size = size.z;
 	}
 
 	return max_size;
@@ -178,167 +174,156 @@ real_t AABB::get_longest_axis_size() const {
 
 real_t AABB::get_shortest_axis_size() const {
 
-	real_t max_size=size.x;
+	real_t max_size = size.x;
 
-	if (size.y < max_size ) {
-		max_size=size.y;
+	if (size.y < max_size) {
+		max_size = size.y;
 	}
 
-	if (size.z < max_size ) {
-		max_size=size.z;
+	if (size.z < max_size) {
+		max_size = size.z;
 	}
 
 	return max_size;
 }
 
-bool AABB::smits_intersect_ray(const Vector3 &from,const Vector3& dir, real_t t0, real_t t1) const {
+bool AABB::smits_intersect_ray(const Vector3 &from, const Vector3 &dir, real_t t0, real_t t1) const {
 
-	real_t divx=1.0/dir.x;
-	real_t divy=1.0/dir.y;
-	real_t divz=1.0/dir.z;
+	real_t divx = 1.0 / dir.x;
+	real_t divy = 1.0 / dir.y;
+	real_t divz = 1.0 / dir.z;
 
-	Vector3 upbound=position+size;
+	Vector3 upbound = position + size;
 	real_t tmin, tmax, tymin, tymax, tzmin, tzmax;
 	if (dir.x >= 0) {
 		tmin = (position.x - from.x) * divx;
 		tmax = (upbound.x - from.x) * divx;
-	}
-	else {
+	} else {
 		tmin = (upbound.x - from.x) * divx;
 		tmax = (position.x - from.x) * divx;
 	}
 	if (dir.y >= 0) {
 		tymin = (position.y - from.y) * divy;
 		tymax = (upbound.y - from.y) * divy;
-	}
-	else {
+	} else {
 		tymin = (upbound.y - from.y) * divy;
 		tymax = (position.y - from.y) * divy;
 	}
-	if ( (tmin > tymax) || (tymin > tmax) )
+	if ((tmin > tymax) || (tymin > tmax))
 		return false;
 	if (tymin > tmin)
-			tmin = tymin;
+		tmin = tymin;
 	if (tymax < tmax)
 		tmax = tymax;
 	if (dir.z >= 0) {
 		tzmin = (position.z - from.z) * divz;
 		tzmax = (upbound.z - from.z) * divz;
-	}
-	else {
+	} else {
 		tzmin = (upbound.z - from.z) * divz;
 		tzmax = (position.z - from.z) * divz;
 	}
-	if ( (tmin > tzmax) || (tzmin > tmax) )
+	if ((tmin > tzmax) || (tzmin > tmax))
 		return false;
 	if (tzmin > tmin)
 		tmin = tzmin;
 	if (tzmax < tmax)
 		tmax = tzmax;
-	return ( (tmin < t1) && (tmax > t0) );
+	return ((tmin < t1) && (tmax > t0));
 }
 
 void AABB::grow_by(real_t p_amount) {
 
-	position.x-=p_amount;
-	position.y-=p_amount;
-	position.z-=p_amount;
-	size.x+=2.0*p_amount;
-	size.y+=2.0*p_amount;
-	size.z+=2.0*p_amount;
+	position.x -= p_amount;
+	position.y -= p_amount;
+	position.z -= p_amount;
+	size.x += 2.0 * p_amount;
+	size.y += 2.0 * p_amount;
+	size.z += 2.0 * p_amount;
 }
 
-
 real_t AABB::get_area() const {
 
-	return size.x*size.y*size.z;
-
+	return size.x * size.y * size.z;
 }
 
-bool AABB::operator==(const AABB& p_rval) const {
-
-	return ((position==p_rval.position) && (size==p_rval.size));
+bool AABB::operator==(const AABB &p_rval) const {
 
+	return ((position == p_rval.position) && (size == p_rval.size));
 }
-bool AABB::operator!=(const AABB& p_rval) const {
-
-	return ((position!=p_rval.position) || (size!=p_rval.size));
+bool AABB::operator!=(const AABB &p_rval) const {
 
+	return ((position != p_rval.position) || (size != p_rval.size));
 }
 
-void AABB::merge_with(const AABB& p_aabb) {
+void AABB::merge_with(const AABB &p_aabb) {
 
-	Vector3 beg_1,beg_2;
-	Vector3 end_1,end_2;
-	Vector3 min,max;
+	Vector3 beg_1, beg_2;
+	Vector3 end_1, end_2;
+	Vector3 min, max;
 
-	beg_1=position;
-	beg_2=p_aabb.position;
-	end_1=Vector3(size.x,size.y,size.z)+beg_1;
-	end_2=Vector3(p_aabb.size.x,p_aabb.size.y,p_aabb.size.z)+beg_2;
+	beg_1 = position;
+	beg_2 = p_aabb.position;
+	end_1 = Vector3(size.x, size.y, size.z) + beg_1;
+	end_2 = Vector3(p_aabb.size.x, p_aabb.size.y, p_aabb.size.z) + beg_2;
 
-	min.x=(beg_1.x<beg_2.x)?beg_1.x:beg_2.x;
-	min.y=(beg_1.y<beg_2.y)?beg_1.y:beg_2.y;
-	min.z=(beg_1.z<beg_2.z)?beg_1.z:beg_2.z;
+	min.x = (beg_1.x < beg_2.x) ? beg_1.x : beg_2.x;
+	min.y = (beg_1.y < beg_2.y) ? beg_1.y : beg_2.y;
+	min.z = (beg_1.z < beg_2.z) ? beg_1.z : beg_2.z;
 
-	max.x=(end_1.x>end_2.x)?end_1.x:end_2.x;
-	max.y=(end_1.y>end_2.y)?end_1.y:end_2.y;
-	max.z=(end_1.z>end_2.z)?end_1.z:end_2.z;
+	max.x = (end_1.x > end_2.x) ? end_1.x : end_2.x;
+	max.y = (end_1.y > end_2.y) ? end_1.y : end_2.y;
+	max.z = (end_1.z > end_2.z) ? end_1.z : end_2.z;
 
-	position=min;
-	size=max-min;
+	position = min;
+	size = max - min;
 }
 
-AABB AABB::intersection(const AABB& p_aabb) const {
+AABB AABB::intersection(const AABB &p_aabb) const {
 
-	Vector3 src_min=position;
-	Vector3 src_max=position+size;
-	Vector3 dst_min=p_aabb.position;
-	Vector3 dst_max=p_aabb.position+p_aabb.size;
+	Vector3 src_min = position;
+	Vector3 src_max = position + size;
+	Vector3 dst_min = p_aabb.position;
+	Vector3 dst_max = p_aabb.position + p_aabb.size;
 
-	Vector3 min,max;
+	Vector3 min, max;
 
-	if (src_min.x > dst_max.x || src_max.x < dst_min.x )
+	if (src_min.x > dst_max.x || src_max.x < dst_min.x)
 		return AABB();
 	else {
 
-		min.x= ( src_min.x > dst_min.x ) ? src_min.x :dst_min.x;
-		max.x= ( src_max.x < dst_max.x ) ? src_max.x :dst_max.x;
-
+		min.x = (src_min.x > dst_min.x) ? src_min.x : dst_min.x;
+		max.x = (src_max.x < dst_max.x) ? src_max.x : dst_max.x;
 	}
 
-	if (src_min.y > dst_max.y || src_max.y < dst_min.y )
+	if (src_min.y > dst_max.y || src_max.y < dst_min.y)
 		return AABB();
 	else {
 
-		min.y= ( src_min.y > dst_min.y ) ? src_min.y :dst_min.y;
-		max.y= ( src_max.y < dst_max.y ) ? src_max.y :dst_max.y;
-
+		min.y = (src_min.y > dst_min.y) ? src_min.y : dst_min.y;
+		max.y = (src_max.y < dst_max.y) ? src_max.y : dst_max.y;
 	}
 
-	if (src_min.z > dst_max.z || src_max.z < dst_min.z )
+	if (src_min.z > dst_max.z || src_max.z < dst_min.z)
 		return AABB();
 	else {
 
-		min.z= ( src_min.z > dst_min.z ) ? src_min.z :dst_min.z;
-		max.z= ( src_max.z < dst_max.z ) ? src_max.z :dst_max.z;
-
+		min.z = (src_min.z > dst_min.z) ? src_min.z : dst_min.z;
+		max.z = (src_max.z < dst_max.z) ? src_max.z : dst_max.z;
 	}
 
-
-	return AABB( min, max-min );
+	return AABB(min, max - min);
 }
 
-bool AABB::intersects_ray(const Vector3& p_from, const Vector3& p_dir,Vector3* r_clip,Vector3* r_normal) const {
+bool AABB::intersects_ray(const Vector3 &p_from, const Vector3 &p_dir, Vector3 *r_clip, Vector3 *r_normal) const {
 
 	Vector3 c1, c2;
-	Vector3 end = position+size;
-	real_t near=-1e20;
-	real_t far=1e20;
-	int axis=0;
+	Vector3 end = position + size;
+	real_t near = -1e20;
+	real_t far = 1e20;
+	int axis = 0;
 
-	for (int i=0;i<3;i++){
-		if (p_dir[i] == 0){
+	for (int i = 0; i < 3; i++) {
+		if (p_dir[i] == 0) {
 			if ((p_from[i] < position[i]) || (p_from[i] > end[i])) {
 				return false;
 			}
@@ -346,71 +331,69 @@ bool AABB::intersects_ray(const Vector3& p_from, const Vector3& p_dir,Vector3* r
 			c1[i] = (position[i] - p_from[i]) / p_dir[i];
 			c2[i] = (end[i] - p_from[i]) / p_dir[i];
 
-			if(c1[i] > c2[i]){
-				std::swap(c1,c2);
+			if (c1[i] > c2[i]) {
+				std::swap(c1, c2);
 			}
-			if (c1[i] > near){
+			if (c1[i] > near) {
 				near = c1[i];
-				axis=i;
+				axis = i;
 			}
-			if (c2[i] < far){
+			if (c2[i] < far) {
 				far = c2[i];
 			}
-			if( (near > far) || (far < 0) ){
+			if ((near > far) || (far < 0)) {
 				return false;
 			}
 		}
 	}
 
 	if (r_clip)
-		*r_clip=c1;
+		*r_clip = c1;
 	if (r_normal) {
-		*r_normal=Vector3();
-		(*r_normal)[axis]=p_dir[axis]?-1:1;
+		*r_normal = Vector3();
+		(*r_normal)[axis] = p_dir[axis] ? -1 : 1;
 	}
 
 	return true;
-
 }
 
+bool AABB::intersects_segment(const Vector3 &p_from, const Vector3 &p_to, Vector3 *r_clip, Vector3 *r_normal) const {
 
-bool AABB::intersects_segment(const Vector3& p_from, const Vector3& p_to,Vector3* r_clip,Vector3* r_normal) const {
+	real_t min = 0, max = 1;
+	int axis = 0;
+	real_t sign = 0;
 
-	real_t min=0,max=1;
-	int axis=0;
-	real_t sign=0;
-
-	for(int i=0;i<3;i++) {
-		real_t seg_from=p_from[i];
-		real_t seg_to=p_to[i];
-		real_t box_begin=position[i];
-		real_t box_end=box_begin+size[i];
-		real_t cmin,cmax;
+	for (int i = 0; i < 3; i++) {
+		real_t seg_from = p_from[i];
+		real_t seg_to = p_to[i];
+		real_t box_begin = position[i];
+		real_t box_end = box_begin + size[i];
+		real_t cmin, cmax;
 		real_t csign;
 
 		if (seg_from < seg_to) {
 
 			if (seg_from > box_end || seg_to < box_begin)
 				return false;
-			real_t length=seg_to-seg_from;
-			cmin = (seg_from < box_begin)?((box_begin - seg_from)/length):0;
-			cmax = (seg_to > box_end)?((box_end - seg_from)/length):1;
-			csign=-1.0;
+			real_t length = seg_to - seg_from;
+			cmin = (seg_from < box_begin) ? ((box_begin - seg_from) / length) : 0;
+			cmax = (seg_to > box_end) ? ((box_end - seg_from) / length) : 1;
+			csign = -1.0;
 
 		} else {
 
 			if (seg_to > box_end || seg_from < box_begin)
 				return false;
-			real_t length=seg_to-seg_from;
-			cmin = (seg_from > box_end)?(box_end - seg_from)/length:0;
-			cmax = (seg_to < box_begin)?(box_begin - seg_from)/length:1;
-			csign=1.0;
+			real_t length = seg_to - seg_from;
+			cmin = (seg_from > box_end) ? (box_end - seg_from) / length : 0;
+			cmax = (seg_to < box_begin) ? (box_begin - seg_from) / length : 1;
+			csign = 1.0;
 		}
 
 		if (cmin > min) {
 			min = cmin;
-			axis=i;
-			sign=csign;
+			axis = i;
+			sign = csign;
 		}
 		if (cmax < max)
 			max = cmax;
@@ -418,217 +401,207 @@ bool AABB::intersects_segment(const Vector3& p_from, const Vector3& p_to,Vector3
 			return false;
 	}
 
-
-	Vector3 rel=p_to-p_from;
+	Vector3 rel = p_to - p_from;
 
 	if (r_normal) {
 		Vector3 normal;
-		normal[axis]=sign;
-		*r_normal=normal;
+		normal[axis] = sign;
+		*r_normal = normal;
 	}
 
 	if (r_clip)
-		*r_clip=p_from+rel*min;
+		*r_clip = p_from + rel * min;
 
 	return true;
-
 }
 
-
 bool AABB::intersects_plane(const Plane &p_plane) const {
 
 	Vector3 points[8] = {
-		Vector3( position.x	, position.y		, position.z		),
-		Vector3( position.x	, position.y		, position.z+size.z	),
-		Vector3( position.x	, position.y+size.y	, position.z		),
-		Vector3( position.x	, position.y+size.y	, position.z+size.z	),
-		Vector3( position.x+size.x	, position.y		, position.z		),
-		Vector3( position.x+size.x	, position.y		, position.z+size.z	),
-		Vector3( position.x+size.x	, position.y+size.y	, position.z		),
-		Vector3( position.x+size.x	, position.y+size.y	, position.z+size.z	),
+		Vector3(position.x, position.y, position.z),
+		Vector3(position.x, position.y, position.z + size.z),
+		Vector3(position.x, position.y + size.y, position.z),
+		Vector3(position.x, position.y + size.y, position.z + size.z),
+		Vector3(position.x + size.x, position.y, position.z),
+		Vector3(position.x + size.x, position.y, position.z + size.z),
+		Vector3(position.x + size.x, position.y + size.y, position.z),
+		Vector3(position.x + size.x, position.y + size.y, position.z + size.z),
 	};
 
-	bool over=false;
-	bool under=false;
+	bool over = false;
+	bool under = false;
 
-	for (int i=0;i<8;i++) {
+	for (int i = 0; i < 8; i++) {
 
-		if (p_plane.distance_to(points[i])>0)
-			over=true;
+		if (p_plane.distance_to(points[i]) > 0)
+			over = true;
 		else
-			under=true;
-
+			under = true;
 	}
 
 	return under && over;
 }
 
-
-
 Vector3 AABB::get_longest_axis() const {
 
-	Vector3 axis(1,0,0);
-	real_t max_size=size.x;
+	Vector3 axis(1, 0, 0);
+	real_t max_size = size.x;
 
-	if (size.y > max_size ) {
-		axis=Vector3(0,1,0);
-		max_size=size.y;
+	if (size.y > max_size) {
+		axis = Vector3(0, 1, 0);
+		max_size = size.y;
 	}
 
-	if (size.z > max_size ) {
-		axis=Vector3(0,0,1);
-		max_size=size.z;
+	if (size.z > max_size) {
+		axis = Vector3(0, 0, 1);
+		max_size = size.z;
 	}
 
 	return axis;
 }
 int AABB::get_longest_axis_index() const {
 
-	int axis=0;
-	real_t max_size=size.x;
+	int axis = 0;
+	real_t max_size = size.x;
 
-	if (size.y > max_size ) {
-		axis=1;
-		max_size=size.y;
+	if (size.y > max_size) {
+		axis = 1;
+		max_size = size.y;
 	}
 
-	if (size.z > max_size ) {
-		axis=2;
-		max_size=size.z;
+	if (size.z > max_size) {
+		axis = 2;
+		max_size = size.z;
 	}
 
 	return axis;
 }
 
-
 Vector3 AABB::get_shortest_axis() const {
 
-	Vector3 axis(1,0,0);
-	real_t max_size=size.x;
+	Vector3 axis(1, 0, 0);
+	real_t max_size = size.x;
 
-	if (size.y < max_size ) {
-		axis=Vector3(0,1,0);
-		max_size=size.y;
+	if (size.y < max_size) {
+		axis = Vector3(0, 1, 0);
+		max_size = size.y;
 	}
 
-	if (size.z < max_size ) {
-		axis=Vector3(0,0,1);
-		max_size=size.z;
+	if (size.z < max_size) {
+		axis = Vector3(0, 0, 1);
+		max_size = size.z;
 	}
 
 	return axis;
 }
 int AABB::get_shortest_axis_index() const {
 
-	int axis=0;
-	real_t max_size=size.x;
+	int axis = 0;
+	real_t max_size = size.x;
 
-	if (size.y < max_size ) {
-		axis=1;
-		max_size=size.y;
+	if (size.y < max_size) {
+		axis = 1;
+		max_size = size.y;
 	}
 
-	if (size.z < max_size ) {
-		axis=2;
-		max_size=size.z;
+	if (size.z < max_size) {
+		axis = 2;
+		max_size = size.z;
 	}
 
 	return axis;
 }
 
-AABB AABB::merge(const AABB& p_with) const {
+AABB AABB::merge(const AABB &p_with) const {
 
-	AABB aabb=*this;
+	AABB aabb = *this;
 	aabb.merge_with(p_with);
 	return aabb;
 }
-AABB AABB::expand(const Vector3& p_vector) const {
-	AABB aabb=*this;
+AABB AABB::expand(const Vector3 &p_vector) const {
+	AABB aabb = *this;
 	aabb.expand_to(p_vector);
 	return aabb;
-
 }
 AABB AABB::grow(real_t p_by) const {
 
-	AABB aabb=*this;
+	AABB aabb = *this;
 	aabb.grow_by(p_by);
 	return aabb;
 }
 
-void AABB::get_edge(int p_edge,Vector3& r_from,Vector3& r_to) const {
+void AABB::get_edge(int p_edge, Vector3 &r_from, Vector3 &r_to) const {
 
-	ERR_FAIL_INDEX(p_edge,12);
-	switch(p_edge) {
+	ERR_FAIL_INDEX(p_edge, 12);
+	switch (p_edge) {
 
-		case 0:{
+		case 0: {
 
-			r_from=Vector3( position.x+size.x	, position.y		, position.z		);
-			r_to=Vector3( position.x	, position.y		, position.z		);
+			r_from = Vector3(position.x + size.x, position.y, position.z);
+			r_to = Vector3(position.x, position.y, position.z);
 		} break;
-		case 1:{
+		case 1: {
 
-			r_from=Vector3( position.x+size.x	, position.y		, position.z+size.z	);
-			r_to=Vector3( position.x+size.x	, position.y		, position.z		);
+			r_from = Vector3(position.x + size.x, position.y, position.z + size.z);
+			r_to = Vector3(position.x + size.x, position.y, position.z);
 		} break;
-		case 2:{
-			r_from=Vector3( position.x	, position.y		, position.z+size.z	);
-			r_to=Vector3( position.x+size.x	, position.y		, position.z+size.z	);
+		case 2: {
+			r_from = Vector3(position.x, position.y, position.z + size.z);
+			r_to = Vector3(position.x + size.x, position.y, position.z + size.z);
 
 		} break;
-		case 3:{
+		case 3: {
 
-			r_from=Vector3( position.x	, position.y		, position.z		);
-			r_to=Vector3( position.x	, position.y		, position.z+size.z	);
+			r_from = Vector3(position.x, position.y, position.z);
+			r_to = Vector3(position.x, position.y, position.z + size.z);
 
 		} break;
-		case 4:{
+		case 4: {
 
-			r_from=Vector3( position.x	, position.y+size.y		, position.z		);
-			r_to=Vector3( position.x+size.x	, position.y+size.y		, position.z		);
+			r_from = Vector3(position.x, position.y + size.y, position.z);
+			r_to = Vector3(position.x + size.x, position.y + size.y, position.z);
 		} break;
-		case 5:{
+		case 5: {
 
-			r_from=Vector3( position.x+size.x	, position.y+size.y		, position.z		);
-			r_to=Vector3( position.x+size.x	, position.y+size.y		, position.z+size.z	);
+			r_from = Vector3(position.x + size.x, position.y + size.y, position.z);
+			r_to = Vector3(position.x + size.x, position.y + size.y, position.z + size.z);
 		} break;
-		case 6:{
-			r_from=Vector3( position.x+size.x	, position.y+size.y		, position.z+size.z	);
-			r_to=Vector3( position.x	, position.y+size.y		, position.z+size.z	);
+		case 6: {
+			r_from = Vector3(position.x + size.x, position.y + size.y, position.z + size.z);
+			r_to = Vector3(position.x, position.y + size.y, position.z + size.z);
 
 		} break;
-		case 7:{
+		case 7: {
 
-			r_from=Vector3( position.x	, position.y+size.y		, position.z+size.z	);
-			r_to=Vector3( position.x	, position.y+size.y		, position.z		);
+			r_from = Vector3(position.x, position.y + size.y, position.z + size.z);
+			r_to = Vector3(position.x, position.y + size.y, position.z);
 
 		} break;
-		case 8:{
+		case 8: {
 
-			r_from=Vector3( position.x	, position.y		, position.z+size.z	);
-			r_to=Vector3( position.x	, position.y+size.y		, position.z+size.z	);
+			r_from = Vector3(position.x, position.y, position.z + size.z);
+			r_to = Vector3(position.x, position.y + size.y, position.z + size.z);
 
 		} break;
-		case 9:{
+		case 9: {
 
-			r_from=Vector3( position.x	, position.y		, position.z		);
-			r_to=Vector3( position.x	, position.y+size.y	, position.z		);
+			r_from = Vector3(position.x, position.y, position.z);
+			r_to = Vector3(position.x, position.y + size.y, position.z);
 
 		} break;
-		case 10:{
+		case 10: {
 
-			r_from=Vector3( position.x+size.x	, position.y		, position.z		);
-			r_to=Vector3( position.x+size.x	, position.y+size.y	, position.z		);
+			r_from = Vector3(position.x + size.x, position.y, position.z);
+			r_to = Vector3(position.x + size.x, position.y + size.y, position.z);
 
 		} break;
-		case 11:{
+		case 11: {
 
-			r_from=Vector3( position.x+size.x	, position.y		, position.z+size.z		);
-			r_to=Vector3( position.x+size.x	, position.y+size.y	, position.z+size.z		);
+			r_from = Vector3(position.x + size.x, position.y, position.z + size.z);
+			r_to = Vector3(position.x + size.x, position.y + size.y, position.z + size.z);
 
 		} break;
-
 	}
-
 }
 
 AABB::operator String() const {
@@ -636,4 +609,4 @@ AABB::operator String() const {
 	return String() + position + " - " + size;
 }
 
-}
+} // namespace godot

src/core/Array.cpp

@@ -1,6 +1,6 @@
 #include "Array.hpp"
-#include "Variant.hpp"
 #include "GodotGlobal.hpp"
+#include "Variant.hpp"
 
 #include <cstdlib>
 
@@ -8,194 +8,158 @@ namespace godot {
 
 class Object;
 
-Array::Array()
-{
+Array::Array() {
 	godot::api->godot_array_new(&_godot_array);
 }
 
-Array::Array(const Array & other)
-{
+Array::Array(const Array &other) {
 	godot::api->godot_array_new_copy(&_godot_array, &other._godot_array);
 }
 
-Array & Array::operator=(const Array & other)
-{
+Array &Array::operator=(const Array &other) {
 	godot::api->godot_array_destroy(&_godot_array);
 	godot::api->godot_array_new_copy(&_godot_array, &other._godot_array);
 	return *this;
 }
 
-Array::Array(const PoolByteArray& a)
-{
-	godot::api->godot_array_new_pool_byte_array(&_godot_array, (godot_pool_byte_array *) &a);
+Array::Array(const PoolByteArray &a) {
+	godot::api->godot_array_new_pool_byte_array(&_godot_array, (godot_pool_byte_array *)&a);
 }
 
-Array::Array(const PoolIntArray& a)
-{
-	godot::api->godot_array_new_pool_int_array(&_godot_array, (godot_pool_int_array *) &a);
+Array::Array(const PoolIntArray &a) {
+	godot::api->godot_array_new_pool_int_array(&_godot_array, (godot_pool_int_array *)&a);
 }
 
-Array::Array(const PoolRealArray& a)
-{
-	godot::api->godot_array_new_pool_real_array(&_godot_array, (godot_pool_real_array *) &a);
+Array::Array(const PoolRealArray &a) {
+	godot::api->godot_array_new_pool_real_array(&_godot_array, (godot_pool_real_array *)&a);
 }
 
-Array::Array(const PoolStringArray& a)
-{
-	godot::api->godot_array_new_pool_string_array(&_godot_array, (godot_pool_string_array *) &a);
+Array::Array(const PoolStringArray &a) {
+	godot::api->godot_array_new_pool_string_array(&_godot_array, (godot_pool_string_array *)&a);
 }
 
-Array::Array(const PoolVector2Array& a)
-{
-	godot::api->godot_array_new_pool_vector2_array(&_godot_array, (godot_pool_vector2_array *) &a);
+Array::Array(const PoolVector2Array &a) {
+	godot::api->godot_array_new_pool_vector2_array(&_godot_array, (godot_pool_vector2_array *)&a);
 }
 
-Array::Array(const PoolVector3Array& a)
-{
-	godot::api->godot_array_new_pool_vector3_array(&_godot_array, (godot_pool_vector3_array *) &a);
+Array::Array(const PoolVector3Array &a) {
+	godot::api->godot_array_new_pool_vector3_array(&_godot_array, (godot_pool_vector3_array *)&a);
 }
 
-Array::Array(const PoolColorArray& a)
-{
-	godot::api->godot_array_new_pool_color_array(&_godot_array, (godot_pool_color_array *) &a);
+Array::Array(const PoolColorArray &a) {
+	godot::api->godot_array_new_pool_color_array(&_godot_array, (godot_pool_color_array *)&a);
 }
 
-Variant& Array::operator [](const int idx)
-{
+Variant &Array::operator[](const int idx) {
 	godot_variant *v = godot::api->godot_array_operator_index(&_godot_array, idx);
-	return *(Variant *) v;
+	return *(Variant *)v;
 }
 
-Variant Array::operator [](const int idx) const
-{
+Variant Array::operator[](const int idx) const {
 	// Yes, I'm casting away the const... you can hate me now.
 	// since the result is
-	godot_variant *v = godot::api->godot_array_operator_index((godot_array *) &_godot_array, idx);
-	return *(Variant *) v;
+	godot_variant *v = godot::api->godot_array_operator_index((godot_array *)&_godot_array, idx);
+	return *(Variant *)v;
 }
 
-void Array::append(const Variant& v)
-{
-	godot::api->godot_array_append(&_godot_array, (godot_variant *) &v);
+void Array::append(const Variant &v) {
+	godot::api->godot_array_append(&_godot_array, (godot_variant *)&v);
 }
 
-void Array::clear()
-{
+void Array::clear() {
 	godot::api->godot_array_clear(&_godot_array);
 }
 
-int Array::count(const Variant& v)
-{
-	return godot::api->godot_array_count(&_godot_array, (godot_variant *) &v);
+int Array::count(const Variant &v) {
+	return godot::api->godot_array_count(&_godot_array, (godot_variant *)&v);
 }
 
-bool Array::empty() const
-{
+bool Array::empty() const {
 	return godot::api->godot_array_empty(&_godot_array);
 }
 
-void Array::erase(const Variant& v)
-{
-	godot::api->godot_array_erase(&_godot_array, (godot_variant *) &v);
+void Array::erase(const Variant &v) {
+	godot::api->godot_array_erase(&_godot_array, (godot_variant *)&v);
 }
 
-Variant Array::front() const
-{
+Variant Array::front() const {
 	godot_variant v = godot::api->godot_array_front(&_godot_array);
-	return *(Variant *) &v;
+	return *(Variant *)&v;
 }
 
-Variant Array::back() const
-{
+Variant Array::back() const {
 	godot_variant v = godot::api->godot_array_back(&_godot_array);
-	return *(Variant *) &v;
+	return *(Variant *)&v;
 }
 
-int Array::find(const Variant& what, const int from)
-{
-	return godot::api->godot_array_find(&_godot_array, (godot_variant *) &what, from);
+int Array::find(const Variant &what, const int from) {
+	return godot::api->godot_array_find(&_godot_array, (godot_variant *)&what, from);
 }
 
-int Array::find_last(const Variant& what)
-{
-	return godot::api->godot_array_find_last(&_godot_array, (godot_variant *) &what);
+int Array::find_last(const Variant &what) {
+	return godot::api->godot_array_find_last(&_godot_array, (godot_variant *)&what);
 }
 
-bool Array::has(const Variant& what) const
-{
-	return godot::api->godot_array_has(&_godot_array, (godot_variant *) &what);
+bool Array::has(const Variant &what) const {
+	return godot::api->godot_array_has(&_godot_array, (godot_variant *)&what);
 }
 
-uint32_t Array::hash() const
-{
+uint32_t Array::hash() const {
 	return godot::api->godot_array_hash(&_godot_array);
 }
 
-void Array::insert(const int pos, const Variant& value)
-{
-	godot::api->godot_array_insert(&_godot_array, pos, (godot_variant *) &value);
+void Array::insert(const int pos, const Variant &value) {
+	godot::api->godot_array_insert(&_godot_array, pos, (godot_variant *)&value);
 }
 
-void Array::invert()
-{
+void Array::invert() {
 	godot::api->godot_array_invert(&_godot_array);
 }
 
-Variant Array::pop_back()
-{
+Variant Array::pop_back() {
 	godot_variant v = godot::api->godot_array_pop_back(&_godot_array);
-	return *(Variant *) &v;
+	return *(Variant *)&v;
 }
 
-Variant Array::pop_front()
-{
+Variant Array::pop_front() {
 	godot_variant v = godot::api->godot_array_pop_front(&_godot_array);
-	return *(Variant *) &v;
+	return *(Variant *)&v;
 }
 
-void Array::push_back(const Variant& v)
-{
-	godot::api->godot_array_push_back(&_godot_array, (godot_variant *) &v);
+void Array::push_back(const Variant &v) {
+	godot::api->godot_array_push_back(&_godot_array, (godot_variant *)&v);
 }
 
-void Array::push_front(const Variant& v)
-{
-	godot::api->godot_array_push_front(&_godot_array, (godot_variant *) &v);
+void Array::push_front(const Variant &v) {
+	godot::api->godot_array_push_front(&_godot_array, (godot_variant *)&v);
 }
 
-void Array::remove(const int idx)
-{
+void Array::remove(const int idx) {
 	godot::api->godot_array_remove(&_godot_array, idx);
 }
 
-int Array::size() const
-{
+int Array::size() const {
 	return godot::api->godot_array_size(&_godot_array);
 }
 
-void Array::resize(const int size)
-{
+void Array::resize(const int size) {
 	godot::api->godot_array_resize(&_godot_array, size);
 }
 
-int Array::rfind(const Variant& what, const int from)
-{
-	return godot::api->godot_array_rfind(&_godot_array, (godot_variant *) &what, from);
+int Array::rfind(const Variant &what, const int from) {
+	return godot::api->godot_array_rfind(&_godot_array, (godot_variant *)&what, from);
 }
 
-void Array::sort()
-{
+void Array::sort() {
 	godot::api->godot_array_sort(&_godot_array);
 }
 
-void Array::sort_custom(Object *obj, const String& func)
-{
-	godot::api->godot_array_sort_custom(&_godot_array, (godot_object *) obj, (godot_string *) &func);
+void Array::sort_custom(Object *obj, const String &func) {
+	godot::api->godot_array_sort_custom(&_godot_array, (godot_object *)obj, (godot_string *)&func);
 }
 
-Array::~Array()
-{
+Array::~Array() {
 	godot::api->godot_array_destroy(&_godot_array);
 }
 
-}
+} // namespace godot

src/core/Basis.cpp

@@ -1,18 +1,16 @@
 #include "Basis.hpp"
 #include "Defs.hpp"
-#include "Vector3.hpp"
 #include "Quat.hpp"
+#include "Vector3.hpp"
 
 #include <algorithm>
 
 namespace godot {
 
-
-Basis::Basis(const Vector3& row0, const Vector3& row1, const Vector3& row2)
-{
-	elements[0]=row0;
-	elements[1]=row1;
-	elements[2]=row2;
+Basis::Basis(const Vector3 &row0, const Vector3 &row1, const Vector3 &row2) {
+	elements[0] = row0;
+	elements[1] = row1;
+	elements[2] = row2;
 }
 
 Basis::Basis(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz) {
@@ -22,58 +20,52 @@ Basis::Basis(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, r
 
 Basis::Basis() {
 
-	elements[0][0]=1;
-	elements[0][1]=0;
-	elements[0][2]=0;
-	elements[1][0]=0;
-	elements[1][1]=1;
-	elements[1][2]=0;
-	elements[2][0]=0;
-	elements[2][1]=0;
-	elements[2][2]=1;
+	elements[0][0] = 1;
+	elements[0][1] = 0;
+	elements[0][2] = 0;
+	elements[1][0] = 0;
+	elements[1][1] = 1;
+	elements[1][2] = 0;
+	elements[2][0] = 0;
+	elements[2][1] = 0;
+	elements[2][2] = 1;
 }
 
-
-
-
-
-const Vector3& Basis::operator[](int axis) const {
+const Vector3 &Basis::operator[](int axis) const {
 
 	return elements[axis];
 }
-Vector3&Basis:: operator[](int axis) {
+Vector3 &Basis::operator[](int axis) {
 
 	return elements[axis];
 }
 
-#define cofac(row1,col1, row2, col2)\
-(elements[row1][col1] * elements[row2][col2] - elements[row1][col2] * elements[row2][col1])
+#define cofac(row1, col1, row2, col2) \
+	(elements[row1][col1] * elements[row2][col2] - elements[row1][col2] * elements[row2][col1])
 
-void Basis::invert()
-{
-	real_t co[3]={
+void Basis::invert() {
+	real_t co[3] = {
 		cofac(1, 1, 2, 2), cofac(1, 2, 2, 0), cofac(1, 0, 2, 1)
 	};
-	real_t det =	elements[0][0] * co[0]+
-			elements[0][1] * co[1]+
-			elements[0][2] * co[2];
+	real_t det = elements[0][0] * co[0] +
+				 elements[0][1] * co[1] +
+				 elements[0][2] * co[2];
 
-	
 	ERR_FAIL_COND(det == 0);
-	
-	real_t s = 1.0/det;
 
-	set(  co[0]*s, cofac(0, 2, 2, 1) * s, cofac(0, 1, 1, 2) * s,
-	      co[1]*s, cofac(0, 0, 2, 2) * s, cofac(0, 2, 1, 0) * s,
-	      co[2]*s, cofac(0, 1, 2, 0) * s, cofac(0, 0, 1, 1) * s );
+	real_t s = 1.0 / det;
+
+	set(co[0] * s, cofac(0, 2, 2, 1) * s, cofac(0, 1, 1, 2) * s,
+			co[1] * s, cofac(0, 0, 2, 2) * s, cofac(0, 2, 1, 0) * s,
+			co[2] * s, cofac(0, 1, 2, 0) * s, cofac(0, 0, 1, 1) * s);
 }
 #undef cofac
 
-bool Basis::isequal_approx(const Basis& a, const Basis& b) const {
+bool Basis::isequal_approx(const Basis &a, const Basis &b) const {
 
-	for (int i=0;i<3;i++) {
-		for (int j=0;j<3;j++) {
-			if ((::fabs(a.elements[i][j]-b.elements[i][j]) < CMP_EPSILON) == false)
+	for (int i = 0; i < 3; i++) {
+		for (int j = 0; j < 3; j++) {
+			if ((::fabs(a.elements[i][j] - b.elements[i][j]) < CMP_EPSILON) == false)
 				return false;
 		}
 	}
@@ -81,102 +73,89 @@ bool Basis::isequal_approx(const Basis& a, const Basis& b) const {
 	return true;
 }
 
-
-bool Basis::is_orthogonal() const
-{
+bool Basis::is_orthogonal() const {
 	Basis id;
-	Basis m = (*this)*transposed();
+	Basis m = (*this) * transposed();
 
-	return isequal_approx(id,m);
+	return isequal_approx(id, m);
 }
 
-bool Basis::is_rotation() const
-{
-	return ::fabs(determinant()-1) < CMP_EPSILON && is_orthogonal();
+bool Basis::is_rotation() const {
+	return ::fabs(determinant() - 1) < CMP_EPSILON && is_orthogonal();
 }
 
-void Basis::transpose()
-{
-	std::swap(elements[0][1],elements[1][0]);
-	std::swap(elements[0][2],elements[2][0]);
-	std::swap(elements[1][2],elements[2][1]);
+void Basis::transpose() {
+	std::swap(elements[0][1], elements[1][0]);
+	std::swap(elements[0][2], elements[2][0]);
+	std::swap(elements[1][2], elements[2][1]);
 }
 
-Basis Basis::inverse() const
-{
+Basis Basis::inverse() const {
 	Basis b = *this;
 	b.invert();
 	return b;
 }
 
-Basis Basis::transposed() const
-{
+Basis Basis::transposed() const {
 	Basis b = *this;
 	b.transpose();
 	return b;
 }
 
-real_t Basis::determinant() const
-{
-	return elements[0][0]*(elements[1][1]*elements[2][2] - elements[2][1]*elements[1][2]) -
-	       elements[1][0]*(elements[0][1]*elements[2][2] - elements[2][1]*elements[0][2]) +
-	       elements[2][0]*(elements[0][1]*elements[1][2] - elements[1][1]*elements[0][2]);
+real_t Basis::determinant() const {
+	return elements[0][0] * (elements[1][1] * elements[2][2] - elements[2][1] * elements[1][2]) -
+		   elements[1][0] * (elements[0][1] * elements[2][2] - elements[2][1] * elements[0][2]) +
+		   elements[2][0] * (elements[0][1] * elements[1][2] - elements[1][1] * elements[0][2]);
 }
 
 Vector3 Basis::get_axis(int p_axis) const {
 	// get actual basis axis (elements is transposed for performance)
-	return Vector3( elements[0][p_axis], elements[1][p_axis], elements[2][p_axis] );
+	return Vector3(elements[0][p_axis], elements[1][p_axis], elements[2][p_axis]);
 }
-void Basis::set_axis(int p_axis, const Vector3& p_value) {
+void Basis::set_axis(int p_axis, const Vector3 &p_value) {
 	// get actual basis axis (elements is transposed for performance)
-	elements[0][p_axis]=p_value.x;
-	elements[1][p_axis]=p_value.y;
-	elements[2][p_axis]=p_value.z;
+	elements[0][p_axis] = p_value.x;
+	elements[1][p_axis] = p_value.y;
+	elements[2][p_axis] = p_value.z;
 }
 
-void Basis::rotate(const Vector3& p_axis, real_t p_phi)
-{
+void Basis::rotate(const Vector3 &p_axis, real_t p_phi) {
 	*this = rotated(p_axis, p_phi);
 }
 
-Basis Basis::rotated(const Vector3& p_axis, real_t p_phi) const
-{
+Basis Basis::rotated(const Vector3 &p_axis, real_t p_phi) const {
 	return Basis(p_axis, p_phi) * (*this);
 }
 
-void Basis::scale( const Vector3& p_scale )
-{
-	elements[0][0]*=p_scale.x;
-	elements[0][1]*=p_scale.x;
-	elements[0][2]*=p_scale.x;
-	elements[1][0]*=p_scale.y;
-	elements[1][1]*=p_scale.y;
-	elements[1][2]*=p_scale.y;
-	elements[2][0]*=p_scale.z;
-	elements[2][1]*=p_scale.z;
-	elements[2][2]*=p_scale.z;
+void Basis::scale(const Vector3 &p_scale) {
+	elements[0][0] *= p_scale.x;
+	elements[0][1] *= p_scale.x;
+	elements[0][2] *= p_scale.x;
+	elements[1][0] *= p_scale.y;
+	elements[1][1] *= p_scale.y;
+	elements[1][2] *= p_scale.y;
+	elements[2][0] *= p_scale.z;
+	elements[2][1] *= p_scale.z;
+	elements[2][2] *= p_scale.z;
 }
 
-Basis Basis::scaled( const Vector3& p_scale ) const
-{
+Basis Basis::scaled(const Vector3 &p_scale) const {
 	Basis b = *this;
 	b.scale(p_scale);
 	return b;
 }
 
-Vector3 Basis::get_scale() const
-{
+Vector3 Basis::get_scale() const {
 	// We are assuming M = R.S, and performing a polar decomposition to extract R and S.
 	// FIXME: We eventually need a proper polar decomposition.
 	// As a cheap workaround until then, to ensure that R is a proper rotation matrix with determinant +1
 	// (such that it can be represented by a Quat or Euler angles), we absorb the sign flip into the scaling matrix.
 	// As such, it works in conjuction with get_rotation().
 	real_t det_sign = determinant() > 0 ? 1 : -1;
-	return det_sign*Vector3(
-		Vector3(elements[0][0],elements[1][0],elements[2][0]).length(),
-		Vector3(elements[0][1],elements[1][1],elements[2][1]).length(),
-		Vector3(elements[0][2],elements[1][2],elements[2][2]).length()
-	);
+	return det_sign * Vector3(
+							  Vector3(elements[0][0], elements[1][0], elements[2][0]).length(),
+							  Vector3(elements[0][1], elements[1][1], elements[2][1]).length(),
+							  Vector3(elements[0][2], elements[1][2], elements[2][2]).length());
 }
 
 // get_euler_xyz returns a vector containing the Euler angles in the format
@@ -322,23 +301,20 @@ void Basis::set_euler_yxz(const Vector3 &p_euler) {
 	*this = ymat * xmat * zmat;
 }
 
-
-
 // transposed dot products
-real_t Basis::tdotx(const Vector3& v) const  {
+real_t Basis::tdotx(const Vector3 &v) const {
 	return elements[0][0] * v[0] + elements[1][0] * v[1] + elements[2][0] * v[2];
 }
-real_t Basis::tdoty(const Vector3& v) const {
+real_t Basis::tdoty(const Vector3 &v) const {
 	return elements[0][1] * v[0] + elements[1][1] * v[1] + elements[2][1] * v[2];
 }
-real_t Basis::tdotz(const Vector3& v) const {
+real_t Basis::tdotz(const Vector3 &v) const {
 	return elements[0][2] * v[0] + elements[1][2] * v[1] + elements[2][2] * v[2];
 }
 
-bool Basis::operator==(const Basis& p_matrix) const
-{
-	for (int i=0;i<3;i++) {
-		for (int j=0;j<3;j++) {
+bool Basis::operator==(const Basis &p_matrix) const {
+	for (int i = 0; i < 3; i++) {
+		for (int j = 0; j < 3; j++) {
 			if (elements[i][j] != p_matrix.elements[i][j])
 				return false;
 		}
@@ -347,69 +323,61 @@ bool Basis::operator==(const Basis& p_matrix) const
 	return true;
 }
 
-bool Basis::operator!=(const Basis& p_matrix) const
-{
-	return (!(*this==p_matrix));
+bool Basis::operator!=(const Basis &p_matrix) const {
+	return (!(*this == p_matrix));
 }
 
-Vector3 Basis::xform(const Vector3& p_vector) const {
+Vector3 Basis::xform(const Vector3 &p_vector) const {
 
 	return Vector3(
-		elements[0].dot(p_vector),
-		elements[1].dot(p_vector),
-		elements[2].dot(p_vector)
-	);
+			elements[0].dot(p_vector),
+			elements[1].dot(p_vector),
+			elements[2].dot(p_vector));
 }
 
-Vector3 Basis::xform_inv(const Vector3& p_vector) const {
+Vector3 Basis::xform_inv(const Vector3 &p_vector) const {
 
 	return Vector3(
-		(elements[0][0]*p_vector.x ) + ( elements[1][0]*p_vector.y ) + ( elements[2][0]*p_vector.z ),
-		(elements[0][1]*p_vector.x ) + ( elements[1][1]*p_vector.y ) + ( elements[2][1]*p_vector.z ),
-		(elements[0][2]*p_vector.x ) + ( elements[1][2]*p_vector.y ) + ( elements[2][2]*p_vector.z )
-	);
+			(elements[0][0] * p_vector.x) + (elements[1][0] * p_vector.y) + (elements[2][0] * p_vector.z),
+			(elements[0][1] * p_vector.x) + (elements[1][1] * p_vector.y) + (elements[2][1] * p_vector.z),
+			(elements[0][2] * p_vector.x) + (elements[1][2] * p_vector.y) + (elements[2][2] * p_vector.z));
 }
-void Basis::operator*=(const Basis& p_matrix)
-{
+void Basis::operator*=(const Basis &p_matrix) {
 	set(
-		p_matrix.tdotx(elements[0]), p_matrix.tdoty(elements[0]), p_matrix.tdotz(elements[0]),
-		p_matrix.tdotx(elements[1]), p_matrix.tdoty(elements[1]), p_matrix.tdotz(elements[1]),
-		p_matrix.tdotx(elements[2]), p_matrix.tdoty(elements[2]), p_matrix.tdotz(elements[2]));
-
+			p_matrix.tdotx(elements[0]), p_matrix.tdoty(elements[0]), p_matrix.tdotz(elements[0]),
+			p_matrix.tdotx(elements[1]), p_matrix.tdoty(elements[1]), p_matrix.tdotz(elements[1]),
+			p_matrix.tdotx(elements[2]), p_matrix.tdoty(elements[2]), p_matrix.tdotz(elements[2]));
 }
 
-Basis Basis::operator*(const Basis& p_matrix) const
-{
+Basis Basis::operator*(const Basis &p_matrix) const {
 	return Basis(
-		p_matrix.tdotx(elements[0]), p_matrix.tdoty(elements[0]), p_matrix.tdotz(elements[0]),
-		p_matrix.tdotx(elements[1]), p_matrix.tdoty(elements[1]), p_matrix.tdotz(elements[1]),
-		p_matrix.tdotx(elements[2]), p_matrix.tdoty(elements[2]), p_matrix.tdotz(elements[2]) );
-
+			p_matrix.tdotx(elements[0]), p_matrix.tdoty(elements[0]), p_matrix.tdotz(elements[0]),
+			p_matrix.tdotx(elements[1]), p_matrix.tdoty(elements[1]), p_matrix.tdotz(elements[1]),
+			p_matrix.tdotx(elements[2]), p_matrix.tdoty(elements[2]), p_matrix.tdotz(elements[2]));
 }
 
-
-void Basis::operator+=(const Basis& p_matrix) {
+void Basis::operator+=(const Basis &p_matrix) {
 
 	elements[0] += p_matrix.elements[0];
 	elements[1] += p_matrix.elements[1];
 	elements[2] += p_matrix.elements[2];
 }
 
-Basis Basis::operator+(const Basis& p_matrix) const {
+Basis Basis::operator+(const Basis &p_matrix) const {
 
 	Basis ret(*this);
 	ret += p_matrix;
 	return ret;
 }
 
-void Basis::operator-=(const Basis& p_matrix) {
+void Basis::operator-=(const Basis &p_matrix) {
 
 	elements[0] -= p_matrix.elements[0];
 	elements[1] -= p_matrix.elements[1];
 	elements[2] -= p_matrix.elements[2];
 }
 
-Basis Basis::operator-(const Basis& p_matrix) const {
+Basis Basis::operator-(const Basis &p_matrix) const {
 
 	Basis ret(*this);
 	ret -= p_matrix;
@@ -418,21 +386,19 @@ Basis Basis::operator-(const Basis& p_matrix) const {
 
 void Basis::operator*=(real_t p_val) {
 
-	elements[0]*=p_val;
-	elements[1]*=p_val;
-	elements[2]*=p_val;
+	elements[0] *= p_val;
+	elements[1] *= p_val;
+	elements[2] *= p_val;
 }
 
 Basis Basis::operator*(real_t p_val) const {
 
-		Basis ret(*this);
-		ret *= p_val;
-		return ret;
+	Basis ret(*this);
+	ret *= p_val;
+	return ret;
 }
 
-
-Basis::operator String() const
-{
+Basis::operator String() const {
 	String s;
 	for (int i = 0; i < 3; i++) {
 
@@ -449,82 +415,77 @@ Basis::operator String() const
 
 /* create / set */
 
-
 void Basis::set(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz) {
 
-	elements[0][0]=xx;
-	elements[0][1]=xy;
-	elements[0][2]=xz;
-	elements[1][0]=yx;
-	elements[1][1]=yy;
-	elements[1][2]=yz;
-	elements[2][0]=zx;
-	elements[2][1]=zy;
-	elements[2][2]=zz;
+	elements[0][0] = xx;
+	elements[0][1] = xy;
+	elements[0][2] = xz;
+	elements[1][0] = yx;
+	elements[1][1] = yy;
+	elements[1][2] = yz;
+	elements[2][0] = zx;
+	elements[2][1] = zy;
+	elements[2][2] = zz;
 }
 Vector3 Basis::get_column(int i) const {
 
-	return Vector3(elements[0][i],elements[1][i],elements[2][i]);
+	return Vector3(elements[0][i], elements[1][i], elements[2][i]);
 }
 
 Vector3 Basis::get_row(int i) const {
 
-	return Vector3(elements[i][0],elements[i][1],elements[i][2]);
+	return Vector3(elements[i][0], elements[i][1], elements[i][2]);
 }
 Vector3 Basis::get_main_diagonal() const {
-	return Vector3(elements[0][0],elements[1][1],elements[2][2]);
+	return Vector3(elements[0][0], elements[1][1], elements[2][2]);
 }
 
-void Basis::set_row(int i, const Vector3& p_row) {
-	elements[i][0]=p_row.x;
-	elements[i][1]=p_row.y;
-	elements[i][2]=p_row.z;
+void Basis::set_row(int i, const Vector3 &p_row) {
+	elements[i][0] = p_row.x;
+	elements[i][1] = p_row.y;
+	elements[i][2] = p_row.z;
 }
 
-Basis Basis::transpose_xform(const Basis& m) const
-{
+Basis Basis::transpose_xform(const Basis &m) const {
 	return Basis(
-		elements[0].x * m[0].x + elements[1].x * m[1].x + elements[2].x * m[2].x,
-		elements[0].x * m[0].y + elements[1].x * m[1].y + elements[2].x * m[2].y,
-		elements[0].x * m[0].z + elements[1].x * m[1].z + elements[2].x * m[2].z,
-		elements[0].y * m[0].x + elements[1].y * m[1].x + elements[2].y * m[2].x,
-		elements[0].y * m[0].y + elements[1].y * m[1].y + elements[2].y * m[2].y,
-		elements[0].y * m[0].z + elements[1].y * m[1].z + elements[2].y * m[2].z,
-		elements[0].z * m[0].x + elements[1].z * m[1].x + elements[2].z * m[2].x,
-		elements[0].z * m[0].y + elements[1].z * m[1].y + elements[2].z * m[2].y,
-		elements[0].z * m[0].z + elements[1].z * m[1].z + elements[2].z * m[2].z);
+			elements[0].x * m[0].x + elements[1].x * m[1].x + elements[2].x * m[2].x,
+			elements[0].x * m[0].y + elements[1].x * m[1].y + elements[2].x * m[2].y,
+			elements[0].x * m[0].z + elements[1].x * m[1].z + elements[2].x * m[2].z,
+			elements[0].y * m[0].x + elements[1].y * m[1].x + elements[2].y * m[2].x,
+			elements[0].y * m[0].y + elements[1].y * m[1].y + elements[2].y * m[2].y,
+			elements[0].y * m[0].z + elements[1].y * m[1].z + elements[2].y * m[2].z,
+			elements[0].z * m[0].x + elements[1].z * m[1].x + elements[2].z * m[2].x,
+			elements[0].z * m[0].y + elements[1].z * m[1].y + elements[2].z * m[2].y,
+			elements[0].z * m[0].z + elements[1].z * m[1].z + elements[2].z * m[2].z);
 }
 
-void Basis::orthonormalize()
-{
+void Basis::orthonormalize() {
 	ERR_FAIL_COND(determinant() == 0);
 
 	// Gram-Schmidt Process
 
-	Vector3 x=get_axis(0);
-	Vector3 y=get_axis(1);
-	Vector3 z=get_axis(2);
+	Vector3 x = get_axis(0);
+	Vector3 y = get_axis(1);
+	Vector3 z = get_axis(2);
 
 	x.normalize();
-	y = (y-x*(x.dot(y)));
+	y = (y - x * (x.dot(y)));
 	y.normalize();
-	z = (z-x*(x.dot(z))-y*(y.dot(z)));
+	z = (z - x * (x.dot(z)) - y * (y.dot(z)));
 	z.normalize();
 
-	set_axis(0,x);
-	set_axis(1,y);
-	set_axis(2,z);
+	set_axis(0, x);
+	set_axis(1, y);
+	set_axis(2, z);
 }
 
-Basis Basis::orthonormalized() const
-{
+Basis Basis::orthonormalized() const {
 	Basis b = *this;
 	b.orthonormalize();
 	return b;
 }
 
-bool Basis::is_symmetric() const
-{
+bool Basis::is_symmetric() const {
 	if (::fabs(elements[0][1] - elements[1][0]) > CMP_EPSILON)
 		return false;
 	if (::fabs(elements[0][2] - elements[2][0]) > CMP_EPSILON)
@@ -535,8 +496,7 @@ bool Basis::is_symmetric() const
 	return true;
 }
 
-Basis Basis::diagonalize()
-{
+Basis Basis::diagonalize() {
 	// I love copy paste
 
 	if (!is_symmetric())
@@ -548,7 +508,7 @@ Basis Basis::diagonalize()
 
 	int ite = 0;
 	Basis acc_rot;
-	while (off_matrix_norm_2 > CMP_EPSILON2 && ite++ < ite_max ) {
+	while (off_matrix_norm_2 > CMP_EPSILON2 && ite++ < ite_max) {
 		real_t el01_2 = elements[0][1] * elements[0][1];
 		real_t el02_2 = elements[0][2] * elements[0][2];
 		real_t el12_2 = elements[1][2] * elements[1][2];
@@ -583,7 +543,7 @@ Basis Basis::diagonalize()
 		// Compute the rotation matrix
 		Basis rot;
 		rot.elements[i][i] = rot.elements[j][j] = ::cos(angle);
-		rot.elements[i][j] = - (rot.elements[j][i] = ::sin(angle));
+		rot.elements[i][j] = -(rot.elements[j][i] = ::sin(angle));
 
 		// Update the off matrix norm
 		off_matrix_norm_2 -= elements[i][j] * elements[i][j];
@@ -596,8 +556,7 @@ Basis Basis::diagonalize()
 	return acc_rot;
 }
 
-
-static const Basis _ortho_bases[24]={
+static const Basis _ortho_bases[24] = {
 	Basis(1, 0, 0, 0, 1, 0, 0, 0, 1),
 	Basis(0, -1, 0, 1, 0, 0, 0, 0, 1),
 	Basis(-1, 0, 0, 0, -1, 0, 0, 0, 1),
@@ -624,95 +583,84 @@ static const Basis _ortho_bases[24]={
 	Basis(0, -1, 0, 0, 0, -1, 1, 0, 0)
 };
 
-
-int Basis::get_orthogonal_index() const
-{
+int Basis::get_orthogonal_index() const {
 	//could be sped up if i come up with a way
-	Basis orth=*this;
-	for(int i=0;i<3;i++) {
-		for(int j=0;j<3;j++) {
+	Basis orth = *this;
+	for (int i = 0; i < 3; i++) {
+		for (int j = 0; j < 3; j++) {
 
 			real_t v = orth[i][j];
-			if (v>0.5)
-				v=1.0;
-			else if (v<-0.5)
-				v=-1.0;
+			if (v > 0.5)
+				v = 1.0;
+			else if (v < -0.5)
+				v = -1.0;
 			else
-				v=0;
+				v = 0;
 
-			orth[i][j]=v;
+			orth[i][j] = v;
 		}
 	}
 
-	for(int i=0;i<24;i++) {
+	for (int i = 0; i < 24; i++) {
 
-		if (_ortho_bases[i]==orth)
+		if (_ortho_bases[i] == orth)
 			return i;
-
-
 	}
 
 	return 0;
 }
 
-
-void Basis::set_orthogonal_index(int p_index){
+void Basis::set_orthogonal_index(int p_index) {
 
 	//there only exist 24 orthogonal bases in r3
 	ERR_FAIL_COND(p_index >= 24);
 
-	*this=_ortho_bases[p_index];
-
+	*this = _ortho_bases[p_index];
 }
 
+Basis::Basis(const Vector3 &p_euler) {
 
-
-Basis::Basis(const Vector3& p_euler) {
-
-	set_euler( p_euler );
-
+	set_euler(p_euler);
 }
 
-}
+} // namespace godot
 
 #include "Quat.hpp"
 
 namespace godot {
 
-Basis::Basis(const Quat& p_quat) {
+Basis::Basis(const Quat &p_quat) {
 
 	real_t d = p_quat.length_squared();
 	real_t s = 2.0 / d;
-	real_t xs = p_quat.x * s,   ys = p_quat.y * s,   zs = p_quat.z * s;
-	real_t wx = p_quat.w * xs,  wy = p_quat.w * ys,  wz = p_quat.w * zs;
-	real_t xx = p_quat.x * xs,  xy = p_quat.x * ys,  xz = p_quat.x * zs;
-	real_t yy = p_quat.y * ys,  yz = p_quat.y * zs,  zz = p_quat.z * zs;
-	set(	1.0 - (yy + zz), xy - wz, xz + wy,
-		xy + wz, 1.0 - (xx + zz), yz - wx,
-		xz - wy, yz + wx, 1.0 - (xx + yy))	;
-
+	real_t xs = p_quat.x * s, ys = p_quat.y * s, zs = p_quat.z * s;
+	real_t wx = p_quat.w * xs, wy = p_quat.w * ys, wz = p_quat.w * zs;
+	real_t xx = p_quat.x * xs, xy = p_quat.x * ys, xz = p_quat.x * zs;
+	real_t yy = p_quat.y * ys, yz = p_quat.y * zs, zz = p_quat.z * zs;
+	set(1.0 - (yy + zz), xy - wz, xz + wy,
+			xy + wz, 1.0 - (xx + zz), yz - wx,
+			xz - wy, yz + wx, 1.0 - (xx + yy));
 }
 
-Basis::Basis(const Vector3& p_axis, real_t p_phi) {
+Basis::Basis(const Vector3 &p_axis, real_t p_phi) {
 	// Rotation matrix from axis and angle, see https://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle
 
-	Vector3 axis_sq(p_axis.x*p_axis.x,p_axis.y*p_axis.y,p_axis.z*p_axis.z);
+	Vector3 axis_sq(p_axis.x * p_axis.x, p_axis.y * p_axis.y, p_axis.z * p_axis.z);
 
-	real_t cosine= ::cos(p_phi);
-	real_t sine= ::sin(p_phi);
+	real_t cosine = ::cos(p_phi);
+	real_t sine = ::sin(p_phi);
 
-	elements[0][0] = axis_sq.x + cosine * ( 1.0 - axis_sq.x );
-	elements[0][1] = p_axis.x * p_axis.y *  ( 1.0 - cosine ) - p_axis.z * sine;
-	elements[0][2] = p_axis.z * p_axis.x * ( 1.0 - cosine ) + p_axis.y * sine;
+	elements[0][0] = axis_sq.x + cosine * (1.0 - axis_sq.x);
+	elements[0][1] = p_axis.x * p_axis.y * (1.0 - cosine) - p_axis.z * sine;
+	elements[0][2] = p_axis.z * p_axis.x * (1.0 - cosine) + p_axis.y * sine;
 
-	elements[1][0] = p_axis.x * p_axis.y * ( 1.0 - cosine ) + p_axis.z * sine;
-	elements[1][1] = axis_sq.y + cosine  * ( 1.0 - axis_sq.y );
-	elements[1][2] = p_axis.y * p_axis.z * ( 1.0 - cosine ) - p_axis.x * sine;
-
-	elements[2][0] = p_axis.z * p_axis.x * ( 1.0 - cosine ) - p_axis.y * sine;
-	elements[2][1] = p_axis.y * p_axis.z * ( 1.0 - cosine ) + p_axis.x * sine;
-	elements[2][2] = axis_sq.z + cosine  * ( 1.0 - axis_sq.z );
+	elements[1][0] = p_axis.x * p_axis.y * (1.0 - cosine) + p_axis.z * sine;
+	elements[1][1] = axis_sq.y + cosine * (1.0 - axis_sq.y);
+	elements[1][2] = p_axis.y * p_axis.z * (1.0 - cosine) - p_axis.x * sine;
 
+	elements[2][0] = p_axis.z * p_axis.x * (1.0 - cosine) - p_axis.y * sine;
+	elements[2][1] = p_axis.y * p_axis.z * (1.0 - cosine) + p_axis.x * sine;
+	elements[2][2] = axis_sq.z + cosine * (1.0 - axis_sq.z);
 }
 
 Basis::operator Quat() const {
@@ -722,21 +670,18 @@ Basis::operator Quat() const {
 	real_t trace = elements[0][0] + elements[1][1] + elements[2][2];
 	real_t temp[4];
 
-	if (trace > 0.0)
-	{
+	if (trace > 0.0) {
 		real_t s = ::sqrt(trace + 1.0);
-		temp[3]=(s * 0.5);
+		temp[3] = (s * 0.5);
 		s = 0.5 / s;
 
-		temp[0]=((elements[2][1] - elements[1][2]) * s);
-		temp[1]=((elements[0][2] - elements[2][0]) * s);
-		temp[2]=((elements[1][0] - elements[0][1]) * s);
-	}
-	else
-	{
+		temp[0] = ((elements[2][1] - elements[1][2]) * s);
+		temp[1] = ((elements[0][2] - elements[2][0]) * s);
+		temp[2] = ((elements[1][0] - elements[0][1]) * s);
+	} else {
 		int i = elements[0][0] < elements[1][1] ?
-			(elements[1][1] < elements[2][2] ? 2 : 1) :
-			(elements[0][0] < elements[2][2] ? 2 : 0);
+						(elements[1][1] < elements[2][2] ? 2 : 1) :
+						(elements[0][0] < elements[2][2] ? 2 : 0);
 		int j = (i + 1) % 3;
 		int k = (i + 2) % 3;
 
@@ -749,11 +694,7 @@ Basis::operator Quat() const {
 		temp[k] = (elements[k][i] + elements[i][k]) * s;
 	}
 
-	return Quat(temp[0],temp[1],temp[2],temp[3]);
-
+	return Quat(temp[0], temp[1], temp[2], temp[3]);
 }
 
-
-
-
-}
+} // namespace godot

src/core/Color.cpp

@@ -12,138 +12,128 @@ namespace godot {
 
 static String _to_hex(float p_val);
 
-static float _parse_col(const String& p_str, int p_ofs) {
+static float _parse_col(const String &p_str, int p_ofs) {
 
-	int ig=0;
+	int ig = 0;
 
-	for(int i=0;i<2;i++) {
+	for (int i = 0; i < 2; i++) {
 
-		int c= (int) (wchar_t) p_str[i+p_ofs];
-		int v=0;
+		int c = (int)(wchar_t)p_str[i + p_ofs];
+		int v = 0;
 
-		if (c>='0' && c<='9') {
-			v=c-'0';
-		} else if (c>='a' && c<='f') {
-			v=c-'a';
-			v+=10;
-		} else if (c>='A' && c<='F') {
-			v=c-'A';
-			v+=10;
+		if (c >= '0' && c <= '9') {
+			v = c - '0';
+		} else if (c >= 'a' && c <= 'f') {
+			v = c - 'a';
+			v += 10;
+		} else if (c >= 'A' && c <= 'F') {
+			v = c - 'A';
+			v += 10;
 		} else {
 			return -1;
 		}
 
-		if (i==0)
-			ig+=v*16;
+		if (i == 0)
+			ig += v * 16;
 		else
-			ig+=v;
-
+			ig += v;
 	}
 
 	return ig;
-
 }
 
-uint32_t Color::to_32() const
-{
+uint32_t Color::to_32() const {
 
-	uint32_t c=(uint8_t)(a*255);
-	c<<=8;
-	c|=(uint8_t)(r*255);
-	c<<=8;
-	c|=(uint8_t)(g*255);
-	c<<=8;
-	c|=(uint8_t)(b*255);
+	uint32_t c = (uint8_t)(a * 255);
+	c <<= 8;
+	c |= (uint8_t)(r * 255);
+	c <<= 8;
+	c |= (uint8_t)(g * 255);
+	c <<= 8;
+	c |= (uint8_t)(b * 255);
 
 	return c;
 }
 
-uint32_t Color::to_ARGB32() const
-{
-	uint32_t c=(uint8_t)(a*255);
-	c<<=8;
-	c|=(uint8_t)(r*255);
-	c<<=8;
-	c|=(uint8_t)(g*255);
-	c<<=8;
-	c|=(uint8_t)(b*255);
+uint32_t Color::to_ARGB32() const {
+	uint32_t c = (uint8_t)(a * 255);
+	c <<= 8;
+	c |= (uint8_t)(r * 255);
+	c <<= 8;
+	c |= (uint8_t)(g * 255);
+	c <<= 8;
+	c |= (uint8_t)(b * 255);
 
 	return c;
 }
 
-float Color::gray() const
-{
-	return (r+g+b)/3.0;
+float Color::gray() const {
+	return (r + g + b) / 3.0;
 }
 
-float Color::get_h() const
-{
+float Color::get_h() const {
 
-	float min = MIN( r, g );
-	min = MIN( min, b );
-	float max = MAX( r, g );
-	max = MAX( max, b );
+	float min = MIN(r, g);
+	min = MIN(min, b);
+	float max = MAX(r, g);
+	max = MAX(max, b);
 
 	float delta = max - min;
 
-	if( delta == 0 )
+	if (delta == 0)
 		return 0;
 
 	float h;
-	if( r == max )
-		h = ( g - b ) / delta;		// between yellow & magenta
-	else if( g == max )
-		h = 2 + ( b - r ) / delta;	// between cyan & yellow
+	if (r == max)
+		h = (g - b) / delta; // between yellow & magenta
+	else if (g == max)
+		h = 2 + (b - r) / delta; // between cyan & yellow
 	else
-		h = 4 + ( r - g ) / delta;	// between magenta & cyan
+		h = 4 + (r - g) / delta; // between magenta & cyan
 
-	h/=6.0;
-	if (h<0)
-		h+=1.0;
+	h /= 6.0;
+	if (h < 0)
+		h += 1.0;
 
 	return h;
 }
 
-float Color::get_s() const
-{
-	float min = MIN( r, g );
-	min = MIN( min, b );
-	float max = MAX( r, g );
-	max = MAX( max, b );
+float Color::get_s() const {
+	float min = MIN(r, g);
+	min = MIN(min, b);
+	float max = MAX(r, g);
+	max = MAX(max, b);
 	float delta = max - min;
-	return (max!=0) ? (delta / max) : 0;
-
+	return (max != 0) ? (delta / max) : 0;
 }
 
-float Color::get_v() const
-{
-	float max = MAX( r, g );
-	max = MAX( max, b );
+float Color::get_v() const {
+	float max = MAX(r, g);
+	max = MAX(max, b);
 	return max;
 }
 
-void Color::set_hsv(float p_h, float p_s, float p_v, float p_alpha)
-{
+void Color::set_hsv(float p_h, float p_s, float p_v, float p_alpha) {
 	int i;
 	float f, p, q, t;
-	a=p_alpha;
+	a = p_alpha;
 
-	if( p_s == 0 ) {
+	if (p_s == 0) {
 		// acp_hromatic (grey)
 		r = g = b = p_v;
 		return;
 	}
 
-	p_h *=6.0;
-	p_h = ::fmod(p_h,6);
-	i = ::floor( p_h );
+	p_h *= 6.0;
+	p_h = ::fmod(p_h, 6);
+	i = ::floor(p_h);
 
 	f = p_h - i;
-	p = p_v * ( 1 - p_s );
-	q = p_v * ( 1 - p_s * f );
-	t = p_v * ( 1 - p_s * ( 1 - f ) );
+	p = p_v * (1 - p_s);
+	q = p_v * (1 - p_s * f);
+	t = p_v * (1 - p_s * (1 - f));
 
-	switch( i ) {
+	switch (i) {
 		case 0: // Red is the dominant color
 			r = p_v;
 			g = t;
@@ -177,56 +167,51 @@ void Color::set_hsv(float p_h, float p_s, float p_v, float p_alpha)
 	}
 }
 
-void Color::invert()
-{
-	r=1.0-r;
-	g=1.0-g;
-	b=1.0-b;
+void Color::invert() {
+	r = 1.0 - r;
+	g = 1.0 - g;
+	b = 1.0 - b;
 }
 
-void Color::contrast()
-{
-	r=::fmod(r+0.5,1.0);
-	g=::fmod(g+0.5,1.0);
-	b=::fmod(b+0.5,1.0);
+void Color::contrast() {
+	r = ::fmod(r + 0.5, 1.0);
+	g = ::fmod(g + 0.5, 1.0);
+	b = ::fmod(b + 0.5, 1.0);
 }
-Color Color::inverted() const
-{
-	Color c=*this;
+Color Color::inverted() const {
+	Color c = *this;
 	c.invert();
 	return c;
 }
-Color Color::contrasted() const
-{
-	Color c=*this;
+Color Color::contrasted() const {
+	Color c = *this;
 	c.contrast();
 	return c;
 }
 
-Color Color::linear_interpolate(const Color& p_b, float p_t) const {
+Color Color::linear_interpolate(const Color &p_b, float p_t) const {
 
-	Color res=*this;
+	Color res = *this;
 
-	res.r+= (p_t * (p_b.r-r));
-	res.g+= (p_t * (p_b.g-g));
-	res.b+= (p_t * (p_b.b-b));
-	res.a+= (p_t * (p_b.a-a));
+	res.r += (p_t * (p_b.r - r));
+	res.g += (p_t * (p_b.g - g));
+	res.b += (p_t * (p_b.b - b));
+	res.a += (p_t * (p_b.a - a));
 
 	return res;
 }
 
-Color Color::blend(const Color& p_over) const {
-
+Color Color::blend(const Color &p_over) const {
 
 	Color res;
 	float sa = 1.0 - p_over.a;
-	res.a = a*sa+p_over.a;
-	if (res.a==0) {
-		return Color(0,0,0,0);
+	res.a = a * sa + p_over.a;
+	if (res.a == 0) {
+		return Color(0, 0, 0, 0);
 	} else {
-		res.r = (r*a*sa + p_over.r * p_over.a)/res.a;
-		res.g = (g*a*sa + p_over.g * p_over.a)/res.a;
-		res.b = (b*a*sa + p_over.b * p_over.a)/res.a;
+		res.r = (r * a * sa + p_over.r * p_over.a) / res.a;
+		res.g = (g * a * sa + p_over.g * p_over.a) / res.a;
+		res.b = (b * a * sa + p_over.b * p_over.a) / res.a;
 	}
 	return res;
 }
@@ -234,114 +219,110 @@ Color Color::blend(const Color& p_over) const {
 Color Color::to_linear() const {
 
 	return Color(
-		r<0.04045 ? r * (1.0 / 12.92) : ::pow((r + 0.055) * (1.0 / (1 + 0.055)), 2.4),
-		g<0.04045 ? g * (1.0 / 12.92) : ::pow((g + 0.055) * (1.0 / (1 + 0.055)), 2.4),
-		b<0.04045 ? b * (1.0 / 12.92) : ::pow((b + 0.055) * (1.0 / (1 + 0.055)), 2.4),
-		a
-	);
+			r < 0.04045 ? r * (1.0 / 12.92) : ::pow((r + 0.055) * (1.0 / (1 + 0.055)), 2.4),
+			g < 0.04045 ? g * (1.0 / 12.92) : ::pow((g + 0.055) * (1.0 / (1 + 0.055)), 2.4),
+			b < 0.04045 ? b * (1.0 / 12.92) : ::pow((b + 0.055) * (1.0 / (1 + 0.055)), 2.4),
+			a);
 }
 
-Color Color::hex(uint32_t p_hex)
-{
-	float a = (p_hex&0xFF)/255.0;
-	p_hex>>=8;
-	float b = (p_hex&0xFF)/255.0;
-	p_hex>>=8;
-	float g = (p_hex&0xFF)/255.0;
-	p_hex>>=8;
-	float r = (p_hex&0xFF)/255.0;
+Color Color::hex(uint32_t p_hex) {
+	float a = (p_hex & 0xFF) / 255.0;
+	p_hex >>= 8;
+	float b = (p_hex & 0xFF) / 255.0;
+	p_hex >>= 8;
+	float g = (p_hex & 0xFF) / 255.0;
+	p_hex >>= 8;
+	float r = (p_hex & 0xFF) / 255.0;
 
-	return Color(r,g,b,a);
+	return Color(r, g, b, a);
 }
 
-Color Color::html(const String& p_color)
-{
+Color Color::html(const String &p_color) {
 	String color = p_color;
-	if (color.length()==0)
+	if (color.length() == 0)
 		return Color();
-	if (color[0]=='#')
-		color=color.substr(1,color.length()-1);
+	if (color[0] == '#')
+		color = color.substr(1, color.length() - 1);
 
-	bool alpha=false;
+	bool alpha = false;
 
-	if (color.length()==8) {
-		alpha=true;
-	} else if (color.length()==6) {
-		alpha=false;
+	if (color.length() == 8) {
+		alpha = true;
+	} else if (color.length() == 6) {
+		alpha = false;
 	} else {
-		ERR_PRINT(String("Invalid Color Code: ") + p_color);
+		ERR_PRINTS(String("Invalid Color Code: ") + p_color);
 		ERR_FAIL_V(Color());
 	}
 
-	int a=255;
+	int a = 255;
 	if (alpha) {
-		a=_parse_col(color,0);
-		if (a<0) {
-			ERR_PRINT("Invalid Color Code: "+p_color);
+		a = _parse_col(color, 0);
+		if (a < 0) {
+			ERR_PRINTS(String("Invalid Color Code: ") + p_color);
 			ERR_FAIL_V(Color());
 		}
 	}
 
-	int from=alpha?2:0;
+	int from = alpha ? 2 : 0;
 
-	int r=_parse_col(color,from+0);
-	if (r<0) {
-		ERR_PRINT("Invalid Color Code: "+p_color);
+	int r = _parse_col(color, from + 0);
+	if (r < 0) {
+		ERR_PRINTS(String("Invalid Color Code: ") + p_color);
 		ERR_FAIL_V(Color());
 	}
-	int g=_parse_col(color,from+2);
-	if (g<0) {
-		ERR_PRINT("Invalid Color Code: "+p_color);
+	int g = _parse_col(color, from + 2);
+	if (g < 0) {
+		ERR_PRINTS(String("Invalid Color Code: ") + p_color);
 		ERR_FAIL_V(Color());
 	}
-	int b=_parse_col(color,from+4);
-	if (b<0) {
-		ERR_PRINT("Invalid Color Code: "+p_color);
+	int b = _parse_col(color, from + 4);
+	if (b < 0) {
+		ERR_PRINTS(String("Invalid Color Code: ") + p_color);
 		ERR_FAIL_V(Color());
 	}
 
-	return Color(r/255.0,g/255.0,b/255.0,a/255.0);
+	return Color(r / 255.0, g / 255.0, b / 255.0, a / 255.0);
 }
 
-bool Color::html_is_valid(const String& p_color)
-{
+bool Color::html_is_valid(const String &p_color) {
 	String color = p_color;
 
-	if (color.length()==0)
+	if (color.length() == 0)
 		return false;
-	if (color[0]=='#')
-		color=color.substr(1,color.length()-1);
+	if (color[0] == '#')
+		color = color.substr(1, color.length() - 1);
 
-	bool alpha=false;
+	bool alpha = false;
 
-	if (color.length()==8) {
-		alpha=true;
-	} else if (color.length()==6) {
-		alpha=false;
+	if (color.length() == 8) {
+		alpha = true;
+	} else if (color.length() == 6) {
+		alpha = false;
 	} else {
 		return false;
 	}
 
-	int a=255;
+	int a = 255;
 	if (alpha) {
-		a=_parse_col(color,0);
-		if (a<0) {
+		a = _parse_col(color, 0);
+		if (a < 0) {
 			return false;
 		}
 	}
 
-	int from=alpha?2:0;
+	int from = alpha ? 2 : 0;
 
-	int r=_parse_col(color,from+0);
-	if (r<0) {
+	int r = _parse_col(color, from + 0);
+	if (r < 0) {
 		return false;
 	}
-	int g=_parse_col(color,from+2);
-	if (g<0) {
+	int g = _parse_col(color, from + 2);
+	if (g < 0) {
 		return false;
 	}
-	int b=_parse_col(color,from+4);
-	if (b<0) {
+	int b = _parse_col(color, from + 4);
+	if (b < 0) {
 		return false;
 	}
 
@@ -349,62 +330,57 @@ bool Color::html_is_valid(const String& p_color)
 }
 
 #ifndef CLAMP
-#define CLAMP(m_a,m_min,m_max) (((m_a)<(m_min))?(m_min):(((m_a)>(m_max))?m_max:m_a))
+#define CLAMP(m_a, m_min, m_max) (((m_a) < (m_min)) ? (m_min) : (((m_a) > (m_max)) ? m_max : m_a))
 #endif
 static String _to_hex(float p_val) {
 
 	int v = p_val * 255;
-	v = CLAMP(v,0,255);
+	v = CLAMP(v, 0, 255);
 	String ret;
 
-	for(int i=0;i<2;i++) {
+	for (int i = 0; i < 2; i++) {
 
-		wchar_t c[2]={0,0};
-		int lv = v&0xF;
-		if (lv<10)
-			c[0]='0'+lv;
+		wchar_t c[2] = { 0, 0 };
+		int lv = v & 0xF;
+		if (lv < 10)
+			c[0] = '0' + lv;
 		else
-			c[0]='a'+lv-10;
+			c[0] = 'a' + lv - 10;
 
-		v>>=4;
-		String cs=(const wchar_t*)c;
+		v >>= 4;
+		String cs = (const wchar_t *)c;
 		ret = cs + ret;
 	}
 
 	return ret;
-
 }
 
-String Color::to_html(bool p_alpha) const
-{
+String Color::to_html(bool p_alpha) const {
 	String txt;
-	txt+=_to_hex(r);
-	txt+=_to_hex(g);
-	txt+=_to_hex(b);
+	txt += _to_hex(r);
+	txt += _to_hex(g);
+	txt += _to_hex(b);
 	if (p_alpha)
-		txt=_to_hex(a)+txt;
+		txt = _to_hex(a) + txt;
 	return txt;
 }
 
-Color::operator String() const
-{
+Color::operator String() const {
 	return String::num(r) + ", " + String::num(g) + ", " + String::num(b) + ", " + String::num(a);
 }
 
+bool Color::operator<(const Color &p_color) const {
 
-bool Color::operator<(const Color& p_color) const {
-
-	if (r==p_color.r) {
-		if (g==p_color.g) {
-			if(b==p_color.b) {
-				return (a<p_color.a);
+	if (r == p_color.r) {
+		if (g == p_color.g) {
+			if (b == p_color.b) {
+				return (a < p_color.a);
 			} else
-				return (b<p_color.b);
+				return (b < p_color.b);
 		} else
-			return g<p_color.g;
+			return g < p_color.g;
 	} else
-		return r<p_color.r;
-
+		return r < p_color.r;
 }
 
-}
+} // namespace godot

src/core/Dictionary.cpp

@@ -1,95 +1,78 @@
 #include "Dictionary.hpp"
-#include "Variant.hpp"
 #include "Array.hpp"
 #include "GodotGlobal.hpp"
+#include "Variant.hpp"
 
 namespace godot {
 
-Dictionary::Dictionary()
-{
+Dictionary::Dictionary() {
 	godot::api->godot_dictionary_new(&_godot_dictionary);
 }
 
-Dictionary::Dictionary(const Dictionary & other)
-{
+Dictionary::Dictionary(const Dictionary &other) {
 	godot::api->godot_dictionary_new_copy(&_godot_dictionary, &other._godot_dictionary);
 }
 
-Dictionary & Dictionary::operator=(const Dictionary & other)
-{
+Dictionary &Dictionary::operator=(const Dictionary &other) {
 	godot::api->godot_dictionary_destroy(&_godot_dictionary);
 	godot::api->godot_dictionary_new_copy(&_godot_dictionary, &other._godot_dictionary);
 	return *this;
 }
 
-void Dictionary::clear()
-{
+void Dictionary::clear() {
 	godot::api->godot_dictionary_clear(&_godot_dictionary);
 }
 
-bool Dictionary::empty() const
-{
+bool Dictionary::empty() const {
 	return godot::api->godot_dictionary_empty(&_godot_dictionary);
 }
 
-void Dictionary::erase(const Variant& key)
-{
-	godot::api->godot_dictionary_erase(&_godot_dictionary, (godot_variant *) &key);
+void Dictionary::erase(const Variant &key) {
+	godot::api->godot_dictionary_erase(&_godot_dictionary, (godot_variant *)&key);
 }
 
-bool Dictionary::has(const Variant& key) const
-{
-	return godot::api->godot_dictionary_has(&_godot_dictionary, (godot_variant *) &key);
+bool Dictionary::has(const Variant &key) const {
+	return godot::api->godot_dictionary_has(&_godot_dictionary, (godot_variant *)&key);
 }
 
-bool Dictionary::has_all(const Array& keys) const
-{
-	return godot::api->godot_dictionary_has_all(&_godot_dictionary, (godot_array *) &keys);
+bool Dictionary::has_all(const Array &keys) const {
+	return godot::api->godot_dictionary_has_all(&_godot_dictionary, (godot_array *)&keys);
 }
 
-uint32_t Dictionary::hash() const
-{
+uint32_t Dictionary::hash() const {
 	return godot::api->godot_dictionary_hash(&_godot_dictionary);
 }
 
-Array Dictionary::keys() const
-{
+Array Dictionary::keys() const {
 	godot_array a = godot::api->godot_dictionary_keys(&_godot_dictionary);
-	return *(Array *) &a;
+	return *(Array *)&a;
 }
 
-Variant &Dictionary::operator [](const Variant& key)
-{
-	return *(Variant *) godot::api->godot_dictionary_operator_index(&_godot_dictionary, (godot_variant *) &key);
+Variant &Dictionary::operator[](const Variant &key) {
+	return *(Variant *)godot::api->godot_dictionary_operator_index(&_godot_dictionary, (godot_variant *)&key);
 }
 
-const Variant &Dictionary::operator [](const Variant& key) const
-{
+const Variant &Dictionary::operator[](const Variant &key) const {
 	// oops I did it again
-	return *(Variant *) godot::api->godot_dictionary_operator_index((godot_dictionary *) &_godot_dictionary, (godot_variant *) &key);
+	return *(Variant *)godot::api->godot_dictionary_operator_index((godot_dictionary *)&_godot_dictionary, (godot_variant *)&key);
 }
 
-int Dictionary::size() const
-{
+int Dictionary::size() const {
 	return godot::api->godot_dictionary_size(&_godot_dictionary);
 }
 
-String Dictionary::to_json() const
-{
+String Dictionary::to_json() const {
 	godot_string s = godot::api->godot_dictionary_to_json(&_godot_dictionary);
-	return *(String *) &s;
+	return *(String *)&s;
 }
 
-Array Dictionary::values() const
-{
+Array Dictionary::values() const {
 	godot_array a = godot::api->godot_dictionary_values(&_godot_dictionary);
-	return *(Array *) &a;
+	return *(Array *)&a;
 }
 
-Dictionary::~Dictionary()
-{
+Dictionary::~Dictionary() {
 	godot::api->godot_dictionary_destroy(&_godot_dictionary);
 }
 
-
-}
+} // namespace godot

src/core/GodotGlobal.cpp

@@ -2,26 +2,46 @@
 
 #include "String.hpp"
 
+#include "Wrapped.hpp"
+
+static GDCALLINGCONV void *wrapper_create(void *data, const void *type_tag, godot_object *instance) {
+	godot::_Wrapped *wrapper_memory = (godot::_Wrapped *)godot::api->godot_alloc(sizeof(godot::_Wrapped));
+
+	if (!wrapper_memory)
+		return NULL;
+	wrapper_memory->_owner = instance;
+	wrapper_memory->_type_tag = (size_t)type_tag;
+
+	return (void *)wrapper_memory;
+}
+
+static GDCALLINGCONV void wrapper_destroy(void *data, void *wrapper) {
+	if (wrapper)
+		godot::api->godot_free(wrapper);
+}
+
 namespace godot {
 
 void *_RegisterState::nativescript_handle;
+int _RegisterState::language_index;
 const godot_gdnative_core_api_struct *api = nullptr;
 const godot_gdnative_ext_nativescript_api_struct *nativescript_api = nullptr;
+const godot_gdnative_ext_nativescript_1_1_api_struct *nativescript_1_1_api = nullptr;
 
-void Godot::print(const String& message)
-{
-	godot::api->godot_print((godot_string *) &message);
+const void *gdnlib = NULL;
+
+void Godot::print(const String &message) {
+	godot::api->godot_print((godot_string *)&message);
 }
 
-void Godot::print_warning(const String& description, const String& function, const String& file, int line)
-{
+void Godot::print_warning(const String &description, const String &function, const String &file, int line) {
 	int len;
 
-	char * c_desc = description.alloc_c_string();
-	char * c_func = function.alloc_c_string();
-	char * c_file = file.alloc_c_string();
+	char *c_desc = description.alloc_c_string();
+	char *c_func = function.alloc_c_string();
+	char *c_file = file.alloc_c_string();
 
-	if (c_desc != nullptr && c_func !=nullptr && c_file != nullptr) {
+	if (c_desc != nullptr && c_func != nullptr && c_file != nullptr) {
 		godot::api->godot_print_warning(c_desc, c_func, c_file, line);
 	};
 
@@ -30,15 +50,14 @@ void Godot::print_warning(const String& description, const String& function, con
 	if (c_file != nullptr) godot::api->godot_free(c_file);
 }
 
-void Godot::print_error(const String& description, const String& function, const String& file, int line)
-{
+void Godot::print_error(const String &description, const String &function, const String &file, int line) {
 	int len;
 
-	char * c_desc = description.alloc_c_string();
-	char * c_func = function.alloc_c_string();
-	char * c_file = file.alloc_c_string();
+	char *c_desc = description.alloc_c_string();
+	char *c_func = function.alloc_c_string();
+	char *c_file = file.alloc_c_string();
 
-	if (c_desc != nullptr && c_func !=nullptr && c_file != nullptr) {
+	if (c_desc != nullptr && c_func != nullptr && c_file != nullptr) {
 		godot::api->godot_print_error(c_desc, c_func, c_file, line);
 	};
 
@@ -47,29 +66,55 @@ void Godot::print_error(const String& description, const String& function, const
 	if (c_file != nullptr) godot::api->godot_free(c_file);
 }
 
-void Godot::gdnative_init(godot_gdnative_init_options *options)
-{
+void ___register_types();
+
+void Godot::gdnative_init(godot_gdnative_init_options *options) {
 	godot::api = options->api_struct;
+	godot::gdnlib = options->gd_native_library;
 
 	// now find our extensions
 	for (int i = 0; i < godot::api->num_extensions; i++) {
 		switch (godot::api->extensions[i]->type) {
 			case GDNATIVE_EXT_NATIVESCRIPT: {
-				godot::nativescript_api = (godot_gdnative_ext_nativescript_api_struct *)godot::api->extensions[i];
-			}; break;
+				godot::nativescript_api = (const godot_gdnative_ext_nativescript_api_struct *)godot::api->extensions[i];
+
+				const godot_gdnative_api_struct *extension = godot::nativescript_api->next;
+
+				while (extension) {
+					if (extension->version.major == 1 && extension->version.minor == 1) {
+						godot::nativescript_1_1_api = (const godot_gdnative_ext_nativescript_1_1_api_struct *)extension;
+					}
+
+					extension = extension->next;
+				}
+			} break;
 			default: break;
-		};
-	};
+		}
+	}
 }
 
-void Godot::gdnative_terminate(godot_gdnative_terminate_options *options)
-{
+void Godot::gdnative_terminate(godot_gdnative_terminate_options *options) {
 	// reserved for future use.
 }
 
-void Godot::nativescript_init(void *handle)
-{
-	godot::_RegisterState::nativescript_handle = handle;
+void Godot::gdnative_profiling_add_data(const char *p_signature, uint64_t p_time) {
+	godot::nativescript_1_1_api->godot_nativescript_profiling_add_data(p_signature, p_time);
 }
 
-};
+void Godot::nativescript_init(void *handle) {
+	godot::_RegisterState::nativescript_handle = handle;
+
+	godot_instance_binding_functions binding_funcs = {};
+	binding_funcs.alloc_instance_binding_data = wrapper_create;
+	binding_funcs.free_instance_binding_data = wrapper_destroy;
+
+	godot::_RegisterState::language_index = godot::nativescript_1_1_api->godot_nativescript_register_instance_binding_data_functions(binding_funcs);
+
+	___register_types();
+}
+
+void Godot::nativescript_terminate(void *handle) {
+	godot::nativescript_1_1_api->godot_nativescript_unregister_instance_binding_data_functions(godot::_RegisterState::language_index);
+}
+
+} // namespace godot

src/core/NodePath.cpp

@@ -1,94 +1,77 @@
 #include "NodePath.hpp"
-#include "String.hpp"
 #include "GodotGlobal.hpp"
+#include "String.hpp"
 
 #include <gdnative/node_path.h>
 
 namespace godot {
 
-
-NodePath::NodePath()
-{
+NodePath::NodePath() {
 	String from = "";
-	godot::api->godot_node_path_new(&_node_path, (godot_string *) &from);
+	godot::api->godot_node_path_new(&_node_path, (godot_string *)&from);
 }
 
-NodePath::NodePath(const NodePath &other)
-{
+NodePath::NodePath(const NodePath &other) {
 	String from = other;
-	godot::api->godot_node_path_new(&_node_path, (godot_string *) &from);
+	godot::api->godot_node_path_new(&_node_path, (godot_string *)&from);
 }
 
-NodePath::NodePath(const String &from)
-{
-	godot::api->godot_node_path_new(&_node_path, (godot_string *) &from);
+NodePath::NodePath(const String &from) {
+	godot::api->godot_node_path_new(&_node_path, (godot_string *)&from);
 }
 
-NodePath::NodePath(const char *contents)
-{
+NodePath::NodePath(const char *contents) {
 	String from = contents;
-	godot::api->godot_node_path_new(&_node_path, (godot_string *) &from);
+	godot::api->godot_node_path_new(&_node_path, (godot_string *)&from);
 }
 
-String NodePath::get_name(const int idx) const
-{
+String NodePath::get_name(const int idx) const {
 	godot_string str = godot::api->godot_node_path_get_name(&_node_path, idx);
 
-	return *(String *) &str;
+	return *(String *)&str;
 }
 
-int NodePath::get_name_count() const
-{
+int NodePath::get_name_count() const {
 	return godot::api->godot_node_path_get_name_count(&_node_path);
 }
 
-String NodePath::get_subname(const int idx) const
-{
+String NodePath::get_subname(const int idx) const {
 	godot_string str = godot::api->godot_node_path_get_subname(&_node_path, idx);
-	return *(String *) &str;
+	return *(String *)&str;
 }
 
-int NodePath::get_subname_count() const
-{
+int NodePath::get_subname_count() const {
 	return godot::api->godot_node_path_get_subname_count(&_node_path);
 }
 
-bool NodePath::is_absolute() const
-{
+bool NodePath::is_absolute() const {
 	return godot::api->godot_node_path_is_absolute(&_node_path);
 }
 
-bool NodePath::is_empty() const
-{
+bool NodePath::is_empty() const {
 	return godot::api->godot_node_path_is_empty(&_node_path);
 }
 
-NodePath::operator String() const
-{
+NodePath::operator String() const {
 	godot_string str = godot::api->godot_node_path_as_string(&_node_path);
 
-	return *(String *) &str;
+	return *(String *)&str;
 }
 
-bool NodePath::operator ==(const NodePath& other)
-{
+bool NodePath::operator==(const NodePath &other) {
 	return godot::api->godot_node_path_operator_equal(&_node_path, &other._node_path);
 }
 
-void NodePath::operator =(const NodePath& other)
-{
+void NodePath::operator=(const NodePath &other) {
 	godot::api->godot_node_path_destroy(&_node_path);
 
-	String other_string = (String) other;
+	String other_string = (String)other;
 
-	godot::api->godot_node_path_new(&_node_path, (godot_string *) &other_string);
+	godot::api->godot_node_path_new(&_node_path, (godot_string *)&other_string);
 }
 
-NodePath::~NodePath()
-{
+NodePath::~NodePath() {
 	godot::api->godot_node_path_destroy(&_node_path);
 }
 
-
-
-}
+} // namespace godot

src/core/Plane.cpp

@@ -5,27 +5,24 @@
 
 namespace godot {
 
-
-void Plane::set_normal(const Vector3& p_normal)
-{
+void Plane::set_normal(const Vector3 &p_normal) {
 	this->normal = p_normal;
 }
 
-Vector3 Plane::project(const Vector3& p_point) const {
+Vector3 Plane::project(const Vector3 &p_point) const {
 
 	return p_point - normal * distance_to(p_point);
 }
 
-
 void Plane::normalize() {
 
 	real_t l = normal.length();
-	if (l==0) {
-		*this=Plane(0,0,0,0);
+	if (l == 0) {
+		*this = Plane(0, 0, 0, 0);
 		return;
 	}
-	normal/=l;
-	d/=l;
+	normal /= l;
+	d /= l;
 }
 
 Plane Plane::normalized() const {
@@ -37,96 +34,95 @@ Plane Plane::normalized() const {
 
 Vector3 Plane::get_any_point() const {
 
-	return get_normal()*d;
+	return get_normal() * d;
 }
 
 Vector3 Plane::get_any_perpendicular_normal() const {
 
-	static const Vector3 p1 = Vector3(1,0,0);
-	static const Vector3 p2 = Vector3(0,1,0);
+	static const Vector3 p1 = Vector3(1, 0, 0);
+	static const Vector3 p2 = Vector3(0, 1, 0);
 	Vector3 p;
 
 	if (::fabs(normal.dot(p1)) > 0.99) // if too similar to p1
-		p=p2; // use p2
+		p = p2; // use p2
 	else
-		p=p1; // use p1
+		p = p1; // use p1
 
-	p-=normal * normal.dot(p);
+	p -= normal * normal.dot(p);
 	p.normalize();
 
 	return p;
 }
 
-
 /* intersections */
 
 bool Plane::intersect_3(const Plane &p_plane1, const Plane &p_plane2, Vector3 *r_result) const {
 
-	const Plane &p_plane0=*this;
-	Vector3 normal0=p_plane0.normal;
-	Vector3 normal1=p_plane1.normal;
-	Vector3 normal2=p_plane2.normal;
+	const Plane &p_plane0 = *this;
+	Vector3 normal0 = p_plane0.normal;
+	Vector3 normal1 = p_plane1.normal;
+	Vector3 normal2 = p_plane2.normal;
 
-	real_t denom=vec3_cross(normal0,normal1).dot(normal2);
+	real_t denom = vec3_cross(normal0, normal1).dot(normal2);
 
-	if (::fabs(denom)<=CMP_EPSILON)
+	if (::fabs(denom) <= CMP_EPSILON)
 		return false;
 
 	if (r_result) {
-		*r_result = 	( (vec3_cross(normal1, normal2) * p_plane0.d) +
-			(vec3_cross(normal2, normal0) * p_plane1.d) +
-			(vec3_cross(normal0, normal1) * p_plane2.d) )/denom;
+		*r_result = ((vec3_cross(normal1, normal2) * p_plane0.d) +
+							(vec3_cross(normal2, normal0) * p_plane1.d) +
+							(vec3_cross(normal0, normal1) * p_plane2.d)) /
+					denom;
 	}
 
 	return true;
 }
 
+bool Plane::intersects_ray(Vector3 p_from, Vector3 p_dir, Vector3 *p_intersection) const {
 
-bool Plane::intersects_ray(Vector3 p_from, Vector3 p_dir, Vector3* p_intersection)  const {
-
-	Vector3 segment=p_dir;
-	real_t den=normal.dot( segment );
+	Vector3 segment = p_dir;
+	real_t den = normal.dot(segment);
 
 	//printf("den is %i\n",den);
-	if (::fabs(den)<=CMP_EPSILON) {
+	if (::fabs(den) <= CMP_EPSILON) {
 
 		return false;
 	}
 
-	real_t dist=(normal.dot( p_from ) - d) / den;
+	real_t dist = (normal.dot(p_from) - d) / den;
 	//printf("dist is %i\n",dist);
 
-	if (dist>CMP_EPSILON) { //this is a ray, before the emiting pos (p_from) doesnt exist
+	if (dist > CMP_EPSILON) { //this is a ray, before the emiting pos (p_from) doesnt exist
 
 		return false;
 	}
 
-	dist=-dist;
+	dist = -dist;
 	*p_intersection = p_from + segment * dist;
 
 	return true;
 }
 
-bool Plane::intersects_segment(Vector3 p_begin, Vector3 p_end, Vector3* p_intersection)  const {
+bool Plane::intersects_segment(Vector3 p_begin, Vector3 p_end, Vector3 *p_intersection) const {
 
-	Vector3 segment= p_begin - p_end;
-	real_t den=normal.dot( segment );
+	Vector3 segment = p_begin - p_end;
+	real_t den = normal.dot(segment);
 
 	//printf("den is %i\n",den);
-	if (::fabs(den)<=CMP_EPSILON) {
+	if (::fabs(den) <= CMP_EPSILON) {
 
 		return false;
 	}
 
-	real_t dist=(normal.dot( p_begin ) - d) / den;
+	real_t dist = (normal.dot(p_begin) - d) / den;
 	//printf("dist is %i\n",dist);
 
-	if (dist<-CMP_EPSILON || dist > (1.0 +CMP_EPSILON)) {
+	if (dist < -CMP_EPSILON || dist > (1.0 + CMP_EPSILON)) {
 
 		return false;
 	}
 
-	dist=-dist;
+	dist = -dist;
 	*p_intersection = p_begin + segment * dist;
 
 	return true;
@@ -134,20 +130,17 @@ bool Plane::intersects_segment(Vector3 p_begin, Vector3 p_end, Vector3* p_inters
 
 /* misc */
 
-bool Plane::is_almost_like(const Plane& p_plane) const {
+bool Plane::is_almost_like(const Plane &p_plane) const {
 
-	return (normal.dot( p_plane.normal ) > _PLANE_EQ_DOT_EPSILON && ::fabs(d-p_plane.d) < _PLANE_EQ_D_EPSILON);
+	return (normal.dot(p_plane.normal) > _PLANE_EQ_DOT_EPSILON && ::fabs(d - p_plane.d) < _PLANE_EQ_D_EPSILON);
 }
 
-
 Plane::operator String() const {
 
 	// return normal.operator String() + ", " + rtos(d);
 	return String(); // @Todo
 }
 
-
-
 bool Plane::is_point_over(const Vector3 &p_point) const {
 
 	return (normal.dot(p_point) > d);
@@ -155,55 +148,47 @@ bool Plane::is_point_over(const Vector3 &p_point) const {
 
 real_t Plane::distance_to(const Vector3 &p_point) const {
 
-	return (normal.dot(p_point)-d);
+	return (normal.dot(p_point) - d);
 }
 
-bool Plane::has_point(const Vector3 &p_point,real_t _epsilon) const {
-
-	real_t dist=normal.dot(p_point) - d;
-	dist=::fabs(dist);
-	return ( dist <= _epsilon);
+bool Plane::has_point(const Vector3 &p_point, real_t _epsilon) const {
 
+	real_t dist = normal.dot(p_point) - d;
+	dist = ::fabs(dist);
+	return (dist <= _epsilon);
 }
 
 Plane::Plane(const Vector3 &p_normal, real_t p_d) {
 
-	normal=p_normal;
-	d=p_d;
+	normal = p_normal;
+	d = p_d;
 }
 
-Plane::Plane(const Vector3 &p_point, const Vector3& p_normal) {
+Plane::Plane(const Vector3 &p_point, const Vector3 &p_normal) {
 
-	normal=p_normal;
-	d=p_normal.dot(p_point);
+	normal = p_normal;
+	d = p_normal.dot(p_point);
 }
 
-Plane::Plane(const Vector3 &p_point1, const Vector3 &p_point2, const Vector3 &p_point3,ClockDirection p_dir) {
+Plane::Plane(const Vector3 &p_point1, const Vector3 &p_point2, const Vector3 &p_point3, ClockDirection p_dir) {
 
 	if (p_dir == CLOCKWISE)
-		normal=(p_point1-p_point3).cross(p_point1-p_point2);
+		normal = (p_point1 - p_point3).cross(p_point1 - p_point2);
 	else
-		normal=(p_point1-p_point2).cross(p_point1-p_point3);
-
+		normal = (p_point1 - p_point2).cross(p_point1 - p_point3);
 
 	normal.normalize();
 	d = normal.dot(p_point1);
-
-
 }
 
-bool Plane::operator==(const Plane& p_plane) const {
+bool Plane::operator==(const Plane &p_plane) const {
 
-	return normal==p_plane.normal && d == p_plane.d;
+	return normal == p_plane.normal && d == p_plane.d;
 }
 
-bool Plane::operator!=(const Plane& p_plane) const {
-
-	return normal!=p_plane.normal || d != p_plane.d;
+bool Plane::operator!=(const Plane &p_plane) const {
 
+	return normal != p_plane.normal || d != p_plane.d;
 }
 
-
-
-
-}
+} // namespace godot

src/core/PoolArrays.cpp

@@ -1,679 +1,541 @@
 #include "PoolArrays.hpp"
-#include "Defs.hpp"
-#include "String.hpp"
 #include "Color.hpp"
+#include "Defs.hpp"
+#include "GodotGlobal.hpp"
+#include "String.hpp"
 #include "Vector2.hpp"
 #include "Vector3.hpp"
-#include "GodotGlobal.hpp"
 
 #include <gdnative/pool_arrays.h>
 
 namespace godot {
 
-PoolByteArray::PoolByteArray()
-{
+PoolByteArray::PoolByteArray() {
 	godot::api->godot_pool_byte_array_new(&_godot_array);
 }
 
-PoolByteArray::PoolByteArray(const PoolByteArray &p_other)
-{
+PoolByteArray::PoolByteArray(const PoolByteArray &p_other) {
 	godot::api->godot_pool_byte_array_new_copy(&_godot_array, &p_other._godot_array);
 }
 
-PoolByteArray &PoolByteArray::operator=(const PoolByteArray & p_other)
-{
+PoolByteArray &PoolByteArray::operator=(const PoolByteArray &p_other) {
 	godot::api->godot_pool_byte_array_destroy(&_godot_array);
 	godot::api->godot_pool_byte_array_new_copy(&_godot_array, &p_other._godot_array);
 	return *this;
 }
 
-PoolByteArray::PoolByteArray(const Array& array)
-{
-	godot::api->godot_pool_byte_array_new_with_array(&_godot_array, (godot_array *) &array);
+PoolByteArray::PoolByteArray(const Array &array) {
+	godot::api->godot_pool_byte_array_new_with_array(&_godot_array, (godot_array *)&array);
 }
 
-PoolByteArray::Read PoolByteArray::read() const
-{
+PoolByteArray::Read PoolByteArray::read() const {
 	Read read;
 	read._read_access = godot::api->godot_pool_byte_array_read(&_godot_array);
 	return read;
 }
 
-PoolByteArray::Write PoolByteArray::write()
-{
+PoolByteArray::Write PoolByteArray::write() {
 	Write write;
 	write._write_access = godot::api->godot_pool_byte_array_write(&_godot_array);
 	return write;
 }
 
-void PoolByteArray::append(const uint8_t data)
-{
+void PoolByteArray::append(const uint8_t data) {
 	godot::api->godot_pool_byte_array_append(&_godot_array, data);
 }
 
-void PoolByteArray::append_array(const PoolByteArray& array)
-{
+void PoolByteArray::append_array(const PoolByteArray &array) {
 	godot::api->godot_pool_byte_array_append_array(&_godot_array, &array._godot_array);
 }
 
-int PoolByteArray::insert(const int idx, const uint8_t data)
-{
+int PoolByteArray::insert(const int idx, const uint8_t data) {
 	return godot::api->godot_pool_byte_array_insert(&_godot_array, idx, data);
 }
 
-void PoolByteArray::invert()
-{
+void PoolByteArray::invert() {
 	godot::api->godot_pool_byte_array_invert(&_godot_array);
 }
 
-void PoolByteArray::push_back(const uint8_t data)
-{
+void PoolByteArray::push_back(const uint8_t data) {
 	godot::api->godot_pool_byte_array_push_back(&_godot_array, data);
 }
 
-void PoolByteArray::remove(const int idx)
-{
+void PoolByteArray::remove(const int idx) {
 	godot::api->godot_pool_byte_array_remove(&_godot_array, idx);
 }
 
-void PoolByteArray::resize(const int size)
-{
+void PoolByteArray::resize(const int size) {
 	godot::api->godot_pool_byte_array_resize(&_godot_array, size);
 }
 
-void PoolByteArray::set(const int idx, const uint8_t data)
-{
+void PoolByteArray::set(const int idx, const uint8_t data) {
 	godot::api->godot_pool_byte_array_set(&_godot_array, idx, data);
 }
 
-uint8_t PoolByteArray::operator [](const int idx)
-{
+uint8_t PoolByteArray::operator[](const int idx) {
 	return godot::api->godot_pool_byte_array_get(&_godot_array, idx);
 }
 
-int PoolByteArray::size() const
-{
+int PoolByteArray::size() const {
 	return godot::api->godot_pool_byte_array_size(&_godot_array);
 }
 
-
-PoolByteArray::~PoolByteArray()
-{
+PoolByteArray::~PoolByteArray() {
 	godot::api->godot_pool_byte_array_destroy(&_godot_array);
 }
 
-
-
-PoolIntArray::PoolIntArray()
-{
+PoolIntArray::PoolIntArray() {
 	godot::api->godot_pool_int_array_new(&_godot_array);
 }
 
-PoolIntArray::PoolIntArray(const PoolIntArray &p_other)
-{
+PoolIntArray::PoolIntArray(const PoolIntArray &p_other) {
 	godot::api->godot_pool_int_array_new_copy(&_godot_array, &p_other._godot_array);
 }
 
-PoolIntArray &PoolIntArray::operator=(const PoolIntArray &p_other)
-{
+PoolIntArray &PoolIntArray::operator=(const PoolIntArray &p_other) {
 	godot::api->godot_pool_int_array_destroy(&_godot_array);
 	godot::api->godot_pool_int_array_new_copy(&_godot_array, &p_other._godot_array);
 	return *this;
 }
 
-PoolIntArray::PoolIntArray(const Array& array)
-{
-	godot::api->godot_pool_int_array_new_with_array(&_godot_array, (godot_array *) &array);
+PoolIntArray::PoolIntArray(const Array &array) {
+	godot::api->godot_pool_int_array_new_with_array(&_godot_array, (godot_array *)&array);
 }
 
-PoolIntArray::Read PoolIntArray::read() const
-{
+PoolIntArray::Read PoolIntArray::read() const {
 	Read read;
 	read._read_access = godot::api->godot_pool_int_array_read(&_godot_array);
 	return read;
 }
 
-PoolIntArray::Write PoolIntArray::write()
-{
+PoolIntArray::Write PoolIntArray::write() {
 	Write write;
 	write._write_access = godot::api->godot_pool_int_array_write(&_godot_array);
 	return write;
 }
 
-void PoolIntArray::append(const int data)
-{
+void PoolIntArray::append(const int data) {
 	godot::api->godot_pool_int_array_append(&_godot_array, data);
 }
 
-void PoolIntArray::append_array(const PoolIntArray& array)
-{
+void PoolIntArray::append_array(const PoolIntArray &array) {
 	godot::api->godot_pool_int_array_append_array(&_godot_array, &array._godot_array);
 }
 
-int PoolIntArray::insert(const int idx, const int data)
-{
+int PoolIntArray::insert(const int idx, const int data) {
 	return godot::api->godot_pool_int_array_insert(&_godot_array, idx, data);
 }
 
-void PoolIntArray::invert()
-{
+void PoolIntArray::invert() {
 	godot::api->godot_pool_int_array_invert(&_godot_array);
 }
 
-void PoolIntArray::push_back(const int data)
-{
+void PoolIntArray::push_back(const int data) {
 	godot::api->godot_pool_int_array_push_back(&_godot_array, data);
 }
 
-void PoolIntArray::remove(const int idx)
-{
+void PoolIntArray::remove(const int idx) {
 	godot::api->godot_pool_int_array_remove(&_godot_array, idx);
 }
 
-void PoolIntArray::resize(const int size)
-{
+void PoolIntArray::resize(const int size) {
 	godot::api->godot_pool_int_array_resize(&_godot_array, size);
 }
 
-void PoolIntArray::set(const int idx, const int data)
-{
+void PoolIntArray::set(const int idx, const int data) {
 	godot::api->godot_pool_int_array_set(&_godot_array, idx, data);
 }
 
-int PoolIntArray::operator [](const int idx)
-{
+int PoolIntArray::operator[](const int idx) {
 	return godot::api->godot_pool_int_array_get(&_godot_array, idx);
 }
 
-int PoolIntArray::size() const
-{
+int PoolIntArray::size() const {
 	return godot::api->godot_pool_int_array_size(&_godot_array);
 }
 
-
-PoolIntArray::~PoolIntArray()
-{
+PoolIntArray::~PoolIntArray() {
 	godot::api->godot_pool_int_array_destroy(&_godot_array);
 }
 
-
-PoolRealArray::PoolRealArray()
-{
+PoolRealArray::PoolRealArray() {
 	godot::api->godot_pool_real_array_new(&_godot_array);
 }
 
-PoolRealArray::PoolRealArray(const PoolRealArray &p_other)
-{
+PoolRealArray::PoolRealArray(const PoolRealArray &p_other) {
 	godot::api->godot_pool_real_array_new_copy(&_godot_array, &p_other._godot_array);
 }
 
-PoolRealArray &PoolRealArray::operator=(const PoolRealArray &p_other)
-{
+PoolRealArray &PoolRealArray::operator=(const PoolRealArray &p_other) {
 	godot::api->godot_pool_real_array_destroy(&_godot_array);
 	godot::api->godot_pool_real_array_new_copy(&_godot_array, &p_other._godot_array);
 	return *this;
 }
 
-PoolRealArray::Read PoolRealArray::read() const
-{
+PoolRealArray::Read PoolRealArray::read() const {
 	Read read;
 	read._read_access = godot::api->godot_pool_real_array_read(&_godot_array);
 	return read;
 }
 
-PoolRealArray::Write PoolRealArray::write()
-{
+PoolRealArray::Write PoolRealArray::write() {
 	Write write;
 	write._write_access = godot::api->godot_pool_real_array_write(&_godot_array);
 	return write;
 }
 
-PoolRealArray::PoolRealArray(const Array& array)
-{
-	godot::api->godot_pool_real_array_new_with_array(&_godot_array, (godot_array *) &array);
+PoolRealArray::PoolRealArray(const Array &array) {
+	godot::api->godot_pool_real_array_new_with_array(&_godot_array, (godot_array *)&array);
 }
 
-void PoolRealArray::append(const real_t data)
-{
+void PoolRealArray::append(const real_t data) {
 	godot::api->godot_pool_real_array_append(&_godot_array, data);
 }
 
-void PoolRealArray::append_array(const PoolRealArray& array)
-{
+void PoolRealArray::append_array(const PoolRealArray &array) {
 	godot::api->godot_pool_real_array_append_array(&_godot_array, &array._godot_array);
 }
 
-int PoolRealArray::insert(const int idx, const real_t data)
-{
+int PoolRealArray::insert(const int idx, const real_t data) {
 	return godot::api->godot_pool_real_array_insert(&_godot_array, idx, data);
 }
 
-void PoolRealArray::invert()
-{
+void PoolRealArray::invert() {
 	godot::api->godot_pool_real_array_invert(&_godot_array);
 }
 
-void PoolRealArray::push_back(const real_t data)
-{
+void PoolRealArray::push_back(const real_t data) {
 	godot::api->godot_pool_real_array_push_back(&_godot_array, data);
 }
 
-void PoolRealArray::remove(const int idx)
-{
+void PoolRealArray::remove(const int idx) {
 	godot::api->godot_pool_real_array_remove(&_godot_array, idx);
 }
 
-void PoolRealArray::resize(const int size)
-{
+void PoolRealArray::resize(const int size) {
 	godot::api->godot_pool_real_array_resize(&_godot_array, size);
 }
 
-void PoolRealArray::set(const int idx, const real_t data)
-{
+void PoolRealArray::set(const int idx, const real_t data) {
 	godot::api->godot_pool_real_array_set(&_godot_array, idx, data);
 }
 
-real_t PoolRealArray::operator [](const int idx)
-{
+real_t PoolRealArray::operator[](const int idx) {
 	return godot::api->godot_pool_real_array_get(&_godot_array, idx);
 }
 
-int PoolRealArray::size() const
-{
+int PoolRealArray::size() const {
 	return godot::api->godot_pool_real_array_size(&_godot_array);
 }
 
-
-PoolRealArray::~PoolRealArray()
-{
+PoolRealArray::~PoolRealArray() {
 	godot::api->godot_pool_real_array_destroy(&_godot_array);
 }
 
-
-
-PoolStringArray::PoolStringArray()
-{
+PoolStringArray::PoolStringArray() {
 	godot::api->godot_pool_string_array_new(&_godot_array);
 }
 
-PoolStringArray::PoolStringArray(const PoolStringArray &p_other)
-{
+PoolStringArray::PoolStringArray(const PoolStringArray &p_other) {
 	godot::api->godot_pool_string_array_new_copy(&_godot_array, &p_other._godot_array);
 }
 
-PoolStringArray &PoolStringArray::operator=(const PoolStringArray &p_other)
-{
+PoolStringArray &PoolStringArray::operator=(const PoolStringArray &p_other) {
 	godot::api->godot_pool_string_array_destroy(&_godot_array);
 	godot::api->godot_pool_string_array_new_copy(&_godot_array, &p_other._godot_array);
 	return *this;
 }
 
-PoolStringArray::PoolStringArray(const Array& array)
-{
-	godot::api->godot_pool_string_array_new_with_array(&_godot_array, (godot_array *) &array);
+PoolStringArray::PoolStringArray(const Array &array) {
+	godot::api->godot_pool_string_array_new_with_array(&_godot_array, (godot_array *)&array);
 }
 
-PoolStringArray::Read PoolStringArray::read() const
-{
+PoolStringArray::Read PoolStringArray::read() const {
 	Read read;
 	read._read_access = godot::api->godot_pool_string_array_read(&_godot_array);
 	return read;
 }
 
-PoolStringArray::Write PoolStringArray::write()
-{
+PoolStringArray::Write PoolStringArray::write() {
 	Write write;
 	write._write_access = godot::api->godot_pool_string_array_write(&_godot_array);
 	return write;
 }
 
-void PoolStringArray::append(const String& data)
-{
-	godot::api->godot_pool_string_array_append(&_godot_array, (godot_string *) &data);
+void PoolStringArray::append(const String &data) {
+	godot::api->godot_pool_string_array_append(&_godot_array, (godot_string *)&data);
 }
 
-void PoolStringArray::append_array(const PoolStringArray& array)
-{
+void PoolStringArray::append_array(const PoolStringArray &array) {
 	godot::api->godot_pool_string_array_append_array(&_godot_array, &array._godot_array);
 }
 
-int PoolStringArray::insert(const int idx, const String& data)
-{
-	return godot::api->godot_pool_string_array_insert(&_godot_array, idx, (godot_string *) &data);
+int PoolStringArray::insert(const int idx, const String &data) {
+	return godot::api->godot_pool_string_array_insert(&_godot_array, idx, (godot_string *)&data);
 }
 
-void PoolStringArray::invert()
-{
+void PoolStringArray::invert() {
 	godot::api->godot_pool_string_array_invert(&_godot_array);
 }
 
-void PoolStringArray::push_back(const String& data)
-{
-	godot::api->godot_pool_string_array_push_back(&_godot_array, (godot_string *) &data);
+void PoolStringArray::push_back(const String &data) {
+	godot::api->godot_pool_string_array_push_back(&_godot_array, (godot_string *)&data);
 }
 
-void PoolStringArray::remove(const int idx)
-{
+void PoolStringArray::remove(const int idx) {
 	godot::api->godot_pool_string_array_remove(&_godot_array, idx);
 }
 
-void PoolStringArray::resize(const int size)
-{
+void PoolStringArray::resize(const int size) {
 	godot::api->godot_pool_string_array_resize(&_godot_array, size);
 }
 
-void PoolStringArray::set(const int idx, const String& data)
-{
-	godot::api->godot_pool_string_array_set(&_godot_array, idx, (godot_string *) &data);
+void PoolStringArray::set(const int idx, const String &data) {
+	godot::api->godot_pool_string_array_set(&_godot_array, idx, (godot_string *)&data);
 }
 
-const String PoolStringArray::operator [](const int idx)
-{
+const String PoolStringArray::operator[](const int idx) {
 	String s;
 	godot_string str = godot::api->godot_pool_string_array_get(&_godot_array, idx);
-	godot::api->godot_string_new_copy((godot_string *) &s, &str);
+	godot::api->godot_string_new_copy((godot_string *)&s, &str);
 	godot::api->godot_string_destroy(&str);
 	return s;
 }
 
-int PoolStringArray::size() const
-{
+int PoolStringArray::size() const {
 	return godot::api->godot_pool_string_array_size(&_godot_array);
 }
 
-
-PoolStringArray::~PoolStringArray()
-{
+PoolStringArray::~PoolStringArray() {
 	godot::api->godot_pool_string_array_destroy(&_godot_array);
 }
 
-
-
-PoolVector2Array::PoolVector2Array()
-{
+PoolVector2Array::PoolVector2Array() {
 	godot::api->godot_pool_vector2_array_new(&_godot_array);
 }
 
-PoolVector2Array::PoolVector2Array(const PoolVector2Array &p_other)
-{
+PoolVector2Array::PoolVector2Array(const PoolVector2Array &p_other) {
 	godot::api->godot_pool_vector2_array_new_copy(&_godot_array, &p_other._godot_array);
 }
 
-PoolVector2Array &PoolVector2Array::operator=(const PoolVector2Array &p_other)
-{
+PoolVector2Array &PoolVector2Array::operator=(const PoolVector2Array &p_other) {
 	godot::api->godot_pool_vector2_array_destroy(&_godot_array);
 	godot::api->godot_pool_vector2_array_new_copy(&_godot_array, &p_other._godot_array);
 	return *this;
 }
 
-PoolVector2Array::PoolVector2Array(const Array& array)
-{
-	godot::api->godot_pool_vector2_array_new_with_array(&_godot_array, (godot_array *) &array);
+PoolVector2Array::PoolVector2Array(const Array &array) {
+	godot::api->godot_pool_vector2_array_new_with_array(&_godot_array, (godot_array *)&array);
 }
 
-PoolVector2Array::Read PoolVector2Array::read() const
-{
+PoolVector2Array::Read PoolVector2Array::read() const {
 	Read read;
 	read._read_access = godot::api->godot_pool_vector2_array_read(&_godot_array);
 	return read;
 }
 
-PoolVector2Array::Write PoolVector2Array::write()
-{
+PoolVector2Array::Write PoolVector2Array::write() {
 	Write write;
 	write._write_access = godot::api->godot_pool_vector2_array_write(&_godot_array);
 	return write;
 }
 
-void PoolVector2Array::append(const Vector2& data)
-{
-	godot::api->godot_pool_vector2_array_append(&_godot_array, (godot_vector2 *) &data);
+void PoolVector2Array::append(const Vector2 &data) {
+	godot::api->godot_pool_vector2_array_append(&_godot_array, (godot_vector2 *)&data);
 }
 
-void PoolVector2Array::append_array(const PoolVector2Array& array)
-{
+void PoolVector2Array::append_array(const PoolVector2Array &array) {
 	godot::api->godot_pool_vector2_array_append_array(&_godot_array, &array._godot_array);
 }
 
-int PoolVector2Array::insert(const int idx, const Vector2& data)
-{
-	return godot::api->godot_pool_vector2_array_insert(&_godot_array, idx, (godot_vector2 *) &data);
+int PoolVector2Array::insert(const int idx, const Vector2 &data) {
+	return godot::api->godot_pool_vector2_array_insert(&_godot_array, idx, (godot_vector2 *)&data);
 }
 
-void PoolVector2Array::invert()
-{
+void PoolVector2Array::invert() {
 	godot::api->godot_pool_vector2_array_invert(&_godot_array);
 }
 
-void PoolVector2Array::push_back(const Vector2& data)
-{
-	godot::api->godot_pool_vector2_array_push_back(&_godot_array, (godot_vector2 *) &data);
+void PoolVector2Array::push_back(const Vector2 &data) {
+	godot::api->godot_pool_vector2_array_push_back(&_godot_array, (godot_vector2 *)&data);
 }
 
-void PoolVector2Array::remove(const int idx)
-{
+void PoolVector2Array::remove(const int idx) {
 	godot::api->godot_pool_vector2_array_remove(&_godot_array, idx);
 }
 
-void PoolVector2Array::resize(const int size)
-{
+void PoolVector2Array::resize(const int size) {
 	godot::api->godot_pool_vector2_array_resize(&_godot_array, size);
 }
 
-void PoolVector2Array::set(const int idx, const Vector2& data)
-{
-	godot::api->godot_pool_vector2_array_set(&_godot_array, idx, (godot_vector2 *) &data);
+void PoolVector2Array::set(const int idx, const Vector2 &data) {
+	godot::api->godot_pool_vector2_array_set(&_godot_array, idx, (godot_vector2 *)&data);
 }
 
-const Vector2 PoolVector2Array::operator [](const int idx)
-{
+const Vector2 PoolVector2Array::operator[](const int idx) {
 	Vector2 v;
-	*(godot_vector2 *) &v = godot::api->godot_pool_vector2_array_get(&_godot_array, idx);
+	*(godot_vector2 *)&v = godot::api->godot_pool_vector2_array_get(&_godot_array, idx);
 	return v;
 }
 
-int PoolVector2Array::size() const
-{
+int PoolVector2Array::size() const {
 	return godot::api->godot_pool_vector2_array_size(&_godot_array);
 }
 
-
-PoolVector2Array::~PoolVector2Array()
-{
+PoolVector2Array::~PoolVector2Array() {
 	godot::api->godot_pool_vector2_array_destroy(&_godot_array);
 }
 
-
-
-PoolVector3Array::PoolVector3Array()
-{
+PoolVector3Array::PoolVector3Array() {
 	godot::api->godot_pool_vector3_array_new(&_godot_array);
 }
 
-PoolVector3Array::PoolVector3Array(const PoolVector3Array &p_other)
-{
+PoolVector3Array::PoolVector3Array(const PoolVector3Array &p_other) {
 	godot::api->godot_pool_vector3_array_new_copy(&_godot_array, &p_other._godot_array);
 }
 
-PoolVector3Array &PoolVector3Array::operator=(const PoolVector3Array &p_other)
-{
+PoolVector3Array &PoolVector3Array::operator=(const PoolVector3Array &p_other) {
 	godot::api->godot_pool_vector3_array_destroy(&_godot_array);
 	godot::api->godot_pool_vector3_array_new_copy(&_godot_array, &p_other._godot_array);
 	return *this;
 }
 
-PoolVector3Array::PoolVector3Array(const Array& array)
-{
-	godot::api->godot_pool_vector3_array_new_with_array(&_godot_array, (godot_array *) &array);
+PoolVector3Array::PoolVector3Array(const Array &array) {
+	godot::api->godot_pool_vector3_array_new_with_array(&_godot_array, (godot_array *)&array);
 }
 
-PoolVector3Array::Read PoolVector3Array::read() const
-{
+PoolVector3Array::Read PoolVector3Array::read() const {
 	Read read;
 	read._read_access = godot::api->godot_pool_vector3_array_read(&_godot_array);
 	return read;
 }
 
-PoolVector3Array::Write PoolVector3Array::write()
-{
+PoolVector3Array::Write PoolVector3Array::write() {
 	Write write;
 	write._write_access = godot::api->godot_pool_vector3_array_write(&_godot_array);
 	return write;
 }
 
-void PoolVector3Array::append(const Vector3& data)
-{
-	godot::api->godot_pool_vector3_array_append(&_godot_array, (godot_vector3 *) &data);
+void PoolVector3Array::append(const Vector3 &data) {
+	godot::api->godot_pool_vector3_array_append(&_godot_array, (godot_vector3 *)&data);
 }
 
-void PoolVector3Array::append_array(const PoolVector3Array& array)
-{
+void PoolVector3Array::append_array(const PoolVector3Array &array) {
 	godot::api->godot_pool_vector3_array_append_array(&_godot_array, &array._godot_array);
 }
 
-int PoolVector3Array::insert(const int idx, const Vector3& data)
-{
-	return godot::api->godot_pool_vector3_array_insert(&_godot_array, idx, (godot_vector3 *) &data);
+int PoolVector3Array::insert(const int idx, const Vector3 &data) {
+	return godot::api->godot_pool_vector3_array_insert(&_godot_array, idx, (godot_vector3 *)&data);
 }
 
-void PoolVector3Array::invert()
-{
+void PoolVector3Array::invert() {
 	godot::api->godot_pool_vector3_array_invert(&_godot_array);
 }
 
-void PoolVector3Array::push_back(const Vector3& data)
-{
-	godot::api->godot_pool_vector3_array_push_back(&_godot_array, (godot_vector3 *) &data);
+void PoolVector3Array::push_back(const Vector3 &data) {
+	godot::api->godot_pool_vector3_array_push_back(&_godot_array, (godot_vector3 *)&data);
 }
 
-void PoolVector3Array::remove(const int idx)
-{
+void PoolVector3Array::remove(const int idx) {
 	godot::api->godot_pool_vector3_array_remove(&_godot_array, idx);
 }
 
-void PoolVector3Array::resize(const int size)
-{
+void PoolVector3Array::resize(const int size) {
 	godot::api->godot_pool_vector3_array_resize(&_godot_array, size);
 }
 
-void PoolVector3Array::set(const int idx, const Vector3& data)
-{
-	godot::api->godot_pool_vector3_array_set(&_godot_array, idx, (godot_vector3 *) &data);
+void PoolVector3Array::set(const int idx, const Vector3 &data) {
+	godot::api->godot_pool_vector3_array_set(&_godot_array, idx, (godot_vector3 *)&data);
 }
 
-const Vector3 PoolVector3Array::operator [](const int idx)
-{
+const Vector3 PoolVector3Array::operator[](const int idx) {
 	Vector3 v;
-	*(godot_vector3 *) &v = godot::api->godot_pool_vector3_array_get(&_godot_array, idx);
+	*(godot_vector3 *)&v = godot::api->godot_pool_vector3_array_get(&_godot_array, idx);
 	return v;
 }
 
-int PoolVector3Array::size() const
-{
+int PoolVector3Array::size() const {
 	return godot::api->godot_pool_vector3_array_size(&_godot_array);
 }
 
-
-PoolVector3Array::~PoolVector3Array()
-{
+PoolVector3Array::~PoolVector3Array() {
 	godot::api->godot_pool_vector3_array_destroy(&_godot_array);
 }
 
-
-PoolColorArray::PoolColorArray()
-{
+PoolColorArray::PoolColorArray() {
 	godot::api->godot_pool_color_array_new(&_godot_array);
 }
 
-PoolColorArray::PoolColorArray(const PoolColorArray &p_other)
-{
+PoolColorArray::PoolColorArray(const PoolColorArray &p_other) {
 	godot::api->godot_pool_color_array_new_copy(&_godot_array, &p_other._godot_array);
 }
 
-PoolColorArray &PoolColorArray::operator=(const PoolColorArray &p_other)
-{
+PoolColorArray &PoolColorArray::operator=(const PoolColorArray &p_other) {
 	godot::api->godot_pool_color_array_destroy(&_godot_array);
 	godot::api->godot_pool_color_array_new_copy(&_godot_array, &p_other._godot_array);
 	return *this;
 }
 
-PoolColorArray::PoolColorArray(const Array& array)
-{
-	godot::api->godot_pool_color_array_new_with_array(&_godot_array, (godot_array *) &array);
+PoolColorArray::PoolColorArray(const Array &array) {
+	godot::api->godot_pool_color_array_new_with_array(&_godot_array, (godot_array *)&array);
 }
 
-PoolColorArray::Read PoolColorArray::read() const
-{
+PoolColorArray::Read PoolColorArray::read() const {
 	Read read;
 	read._read_access = godot::api->godot_pool_color_array_read(&_godot_array);
 	return read;
 }
 
-PoolColorArray::Write PoolColorArray::write()
-{
+PoolColorArray::Write PoolColorArray::write() {
 	Write write;
 	write._write_access = godot::api->godot_pool_color_array_write(&_godot_array);
 	return write;
 }
 
-void PoolColorArray::append(const Color& data)
-{
-	godot::api->godot_pool_color_array_append(&_godot_array, (godot_color *) &data);
+void PoolColorArray::append(const Color &data) {
+	godot::api->godot_pool_color_array_append(&_godot_array, (godot_color *)&data);
 }
 
-void PoolColorArray::append_array(const PoolColorArray& array)
-{
+void PoolColorArray::append_array(const PoolColorArray &array) {
 	godot::api->godot_pool_color_array_append_array(&_godot_array, &array._godot_array);
 }
 
-int PoolColorArray::insert(const int idx, const Color& data)
-{
-	return godot::api->godot_pool_color_array_insert(&_godot_array, idx, (godot_color *) &data);
+int PoolColorArray::insert(const int idx, const Color &data) {
+	return godot::api->godot_pool_color_array_insert(&_godot_array, idx, (godot_color *)&data);
 }
 
-void PoolColorArray::invert()
-{
+void PoolColorArray::invert() {
 	godot::api->godot_pool_color_array_invert(&_godot_array);
 }
 
-void PoolColorArray::push_back(const Color& data)
-{
-	godot::api->godot_pool_color_array_push_back(&_godot_array, (godot_color *) &data);
+void PoolColorArray::push_back(const Color &data) {
+	godot::api->godot_pool_color_array_push_back(&_godot_array, (godot_color *)&data);
 }
 
-void PoolColorArray::remove(const int idx)
-{
+void PoolColorArray::remove(const int idx) {
 	godot::api->godot_pool_color_array_remove(&_godot_array, idx);
 }
 
-void PoolColorArray::resize(const int size)
-{
+void PoolColorArray::resize(const int size) {
 	godot::api->godot_pool_color_array_resize(&_godot_array, size);
 }
 
-void PoolColorArray::set(const int idx, const Color& data)
-{
-	godot::api->godot_pool_color_array_set(&_godot_array, idx, (godot_color *) &data);
+void PoolColorArray::set(const int idx, const Color &data) {
+	godot::api->godot_pool_color_array_set(&_godot_array, idx, (godot_color *)&data);
 }
 
-const Color PoolColorArray::operator [](const int idx)
-{
+const Color PoolColorArray::operator[](const int idx) {
 	Color v;
-	*(godot_color *) &v = godot::api->godot_pool_color_array_get(&_godot_array, idx);
+	*(godot_color *)&v = godot::api->godot_pool_color_array_get(&_godot_array, idx);
 	return v;
 }
 
-int PoolColorArray::size() const
-{
+int PoolColorArray::size() const {
 	return godot::api->godot_pool_color_array_size(&_godot_array);
 }
 
-
-PoolColorArray::~PoolColorArray()
-{
+PoolColorArray::~PoolColorArray() {
 	godot::api->godot_pool_color_array_destroy(&_godot_array);
 }
 
-
-
-}
+} // namespace godot

src/core/Quat.cpp

@@ -1,7 +1,7 @@
 #include "Quat.hpp"
+#include "Basis.hpp"
 #include "Defs.hpp"
 #include "Vector3.hpp"
-#include "Basis.hpp"
 
 #include <cmath>
 
@@ -77,53 +77,47 @@ Vector3 Quat::get_euler_yxz() const {
 	return m.get_euler_yxz();
 }
 
-real_t Quat::length() const
-{
+real_t Quat::length() const {
 	return ::sqrt(length_squared());
 }
 
-void Quat::normalize()
-{
+void Quat::normalize() {
 	*this /= length();
 }
 
-Quat Quat::normalized() const
-{
+Quat Quat::normalized() const {
 	return *this / length();
 }
 
-Quat Quat::inverse() const
-{
-	return Quat( -x, -y, -z, w );
+Quat Quat::inverse() const {
+	return Quat(-x, -y, -z, w);
 }
 
-Quat Quat::slerp(const Quat& q, const real_t& t) const {
-
-	Quat          to1;
-	real_t        omega, cosom, sinom, scale0, scale1;
+Quat Quat::slerp(const Quat &q, const real_t &t) const {
 
+	Quat to1;
+	real_t omega, cosom, sinom, scale0, scale1;
 
 	// calc cosine
 	cosom = dot(q);
 
 	// adjust signs (if necessary)
-	if ( cosom <0.0 ) {
+	if (cosom < 0.0) {
 		cosom = -cosom;
-		to1.x = - q.x;
-		to1.y = - q.y;
-		to1.z = - q.z;
-		to1.w = - q.w;
-	} else  {
+		to1.x = -q.x;
+		to1.y = -q.y;
+		to1.z = -q.z;
+		to1.w = -q.w;
+	} else {
 		to1.x = q.x;
 		to1.y = q.y;
 		to1.z = q.z;
 		to1.w = q.w;
 	}
 
-
 	// calculate coefficients
 
-	if ( (1.0 - cosom) > CMP_EPSILON ) {
+	if ((1.0 - cosom) > CMP_EPSILON) {
 		// standard case (slerp)
 		omega = ::acos(cosom);
 		sinom = ::sin(omega);
@@ -137,14 +131,13 @@ Quat Quat::slerp(const Quat& q, const real_t& t) const {
 	}
 	// calculate final values
 	return Quat(
-		scale0 * x + scale1 * to1.x,
-		scale0 * y + scale1 * to1.y,
-		scale0 * z + scale1 * to1.z,
-		scale0 * w + scale1 * to1.w
-	);
+			scale0 * x + scale1 * to1.x,
+			scale0 * y + scale1 * to1.y,
+			scale0 * z + scale1 * to1.z,
+			scale0 * w + scale1 * to1.w);
 }
 
-Quat Quat::slerpni(const Quat& q, const real_t& t) const {
+Quat Quat::slerpni(const Quat &q, const real_t &t) const {
 
 	const Quat &from = *this;
 
@@ -152,162 +145,161 @@ Quat Quat::slerpni(const Quat& q, const real_t& t) const {
 
 	if (::fabs(dot) > 0.9999) return from;
 
-	real_t	theta		= ::acos(dot),
-		sinT		= 1.0 / ::sin(theta),
-		newFactor	= ::sin(t * theta) * sinT,
-		invFactor	= ::sin((1.0 - t) * theta) * sinT;
+	real_t theta = ::acos(dot),
+		   sinT = 1.0 / ::sin(theta),
+		   newFactor = ::sin(t * theta) * sinT,
+		   invFactor = ::sin((1.0 - t) * theta) * sinT;
 
 	return Quat(invFactor * from.x + newFactor * q.x,
-				invFactor * from.y + newFactor * q.y,
-				invFactor * from.z + newFactor * q.z,
-				invFactor * from.w + newFactor * q.w);
+			invFactor * from.y + newFactor * q.y,
+			invFactor * from.z + newFactor * q.z,
+			invFactor * from.w + newFactor * q.w);
 }
 
-Quat Quat::cubic_slerp(const Quat& q, const Quat& prep, const Quat& postq,const real_t& t) const
-{
+Quat Quat::cubic_slerp(const Quat &q, const Quat &prep, const Quat &postq, const real_t &t) const {
 	//the only way to do slerp :|
-	real_t t2 = (1.0-t)*t*2;
-	Quat sp = this->slerp(q,t);
-	Quat sq = prep.slerpni(postq,t);
-	return sp.slerpni(sq,t2);
+	real_t t2 = (1.0 - t) * t * 2;
+	Quat sp = this->slerp(q, t);
+	Quat sq = prep.slerpni(postq, t);
+	return sp.slerpni(sq, t2);
 }
 
-void Quat::get_axis_and_angle(Vector3& r_axis, real_t &r_angle) const {
+void Quat::get_axis_and_angle(Vector3 &r_axis, real_t &r_angle) const {
 	r_angle = 2 * ::acos(w);
-	r_axis.x = x / ::sqrt(1-w*w);
-	r_axis.y = y / ::sqrt(1-w*w);
-	r_axis.z = z / ::sqrt(1-w*w);
+	r_axis.x = x / ::sqrt(1 - w * w);
+	r_axis.y = y / ::sqrt(1 - w * w);
+	r_axis.z = z / ::sqrt(1 - w * w);
 }
 
-
-
-Quat Quat::operator*(const Vector3& v) const
-{
-	return Quat( w * v.x + y * v.z - z * v.y,
-		w * v.y + z * v.x - x * v.z,
-		w * v.z + x * v.y - y * v.x,
-		-x * v.x - y * v.y - z * v.z);
+Quat Quat::operator*(const Vector3 &v) const {
+	return Quat(w * v.x + y * v.z - z * v.y,
+			w * v.y + z * v.x - x * v.z,
+			w * v.z + x * v.y - y * v.x,
+			-x * v.x - y * v.y - z * v.z);
 }
 
-Vector3 Quat::xform(const Vector3& v) const {
+Vector3 Quat::xform(const Vector3 &v) const {
 
 	Quat q = *this * v;
 	q *= this->inverse();
-	return Vector3(q.x,q.y,q.z);
+	return Vector3(q.x, q.y, q.z);
 }
 
-
-Quat::operator String() const
-{
+Quat::operator String() const {
 	return String(); // @Todo
 }
 
-
-Quat::Quat(const Vector3& axis, const real_t& angle)
-{
+Quat::Quat(const Vector3 &axis, const real_t &angle) {
 	real_t d = axis.length();
-	if (d==0)
-		set(0,0,0,0);
+	if (d == 0)
+		set(0, 0, 0, 0);
 	else {
 		real_t sin_angle = ::sin(angle * 0.5);
 		real_t cos_angle = ::cos(angle * 0.5);
 		real_t s = sin_angle / d;
 		set(axis.x * s, axis.y * s, axis.z * s,
-			cos_angle);
+				cos_angle);
 	}
 }
 
-Quat::Quat(const Vector3& v0, const Vector3& v1) // shortest arc
+Quat::Quat(const Vector3 &v0, const Vector3 &v1) // shortest arc
 {
 	Vector3 c = v0.cross(v1);
-	real_t  d = v0.dot(v1);
+	real_t d = v0.dot(v1);
 
 	if (d < -1.0 + CMP_EPSILON) {
-		x=0;
-		y=1;
-		z=0;
-		w=0;
+		x = 0;
+		y = 1;
+		z = 0;
+		w = 0;
 	} else {
 
-		real_t  s = ::sqrt((1.0 + d) * 2.0);
+		real_t s = ::sqrt((1.0 + d) * 2.0);
 		real_t rs = 1.0 / s;
 
-		x=c.x*rs;
-		y=c.y*rs;
-		z=c.z*rs;
-		w=s * 0.5;
+		x = c.x * rs;
+		y = c.y * rs;
+		z = c.z * rs;
+		w = s * 0.5;
 	}
 }
 
-
-real_t Quat::dot(const Quat& q) const {
-	return x * q.x+y * q.y+z * q.z+w * q.w;
+real_t Quat::dot(const Quat &q) const {
+	return x * q.x + y * q.y + z * q.z + w * q.w;
 }
 
 real_t Quat::length_squared() const {
 	return dot(*this);
 }
 
-void Quat::operator+=(const Quat& q) {
-	x += q.x; y += q.y; z += q.z; w += q.w;
+void Quat::operator+=(const Quat &q) {
+	x += q.x;
+	y += q.y;
+	z += q.z;
+	w += q.w;
 }
 
-void Quat::operator-=(const Quat& q) {
-	x -= q.x; y -= q.y; z -= q.z; w -= q.w;
+void Quat::operator-=(const Quat &q) {
+	x -= q.x;
+	y -= q.y;
+	z -= q.z;
+	w -= q.w;
 }
 
-void Quat::operator*=(const Quat& q) {
-	x *= q.x; y *= q.y; z *= q.z; w *= q.w;
+void Quat::operator*=(const Quat &q) {
+	x *= q.x;
+	y *= q.y;
+	z *= q.z;
+	w *= q.w;
 }
 
-
-void Quat::operator*=(const real_t& s) {
-	x *= s; y *= s; z *= s; w *= s;
+void Quat::operator*=(const real_t &s) {
+	x *= s;
+	y *= s;
+	z *= s;
+	w *= s;
 }
 
-
-void Quat::operator/=(const real_t& s) {
+void Quat::operator/=(const real_t &s) {
 
 	*this *= 1.0 / s;
 }
 
-Quat Quat::operator+(const Quat& q2) const {
-	const Quat& q1 = *this;
-	return Quat( q1.x+q2.x, q1.y+q2.y, q1.z+q2.z, q1.w+q2.w );
+Quat Quat::operator+(const Quat &q2) const {
+	const Quat &q1 = *this;
+	return Quat(q1.x + q2.x, q1.y + q2.y, q1.z + q2.z, q1.w + q2.w);
 }
 
-Quat Quat::operator-(const Quat& q2) const {
-	const Quat& q1 = *this;
-	return Quat( q1.x-q2.x, q1.y-q2.y, q1.z-q2.z, q1.w-q2.w);
+Quat Quat::operator-(const Quat &q2) const {
+	const Quat &q1 = *this;
+	return Quat(q1.x - q2.x, q1.y - q2.y, q1.z - q2.z, q1.w - q2.w);
 }
 
-Quat Quat::operator*(const Quat& q2) const {
+Quat Quat::operator*(const Quat &q2) const {
 	Quat q1 = *this;
 	q1 *= q2;
 	return q1;
 }
 
-
 Quat Quat::operator-() const {
-	const Quat& q2 = *this;
-	return Quat( -q2.x, -q2.y,  -q2.z,  -q2.w);
+	const Quat &q2 = *this;
+	return Quat(-q2.x, -q2.y, -q2.z, -q2.w);
 }
 
-Quat Quat::operator*(const real_t& s) const {
+Quat Quat::operator*(const real_t &s) const {
 	return Quat(x * s, y * s, z * s, w * s);
 }
 
-Quat Quat::operator/(const real_t& s) const {
+Quat Quat::operator/(const real_t &s) const {
 	return *this * (1.0 / s);
 }
 
-
-bool Quat::operator==(const Quat& p_quat) const {
-	return x==p_quat.x && y==p_quat.y && z==p_quat.z && w==p_quat.w;
+bool Quat::operator==(const Quat &p_quat) const {
+	return x == p_quat.x && y == p_quat.y && z == p_quat.z && w == p_quat.w;
 }
 
-bool Quat::operator!=(const Quat& p_quat) const {
-	return x!=p_quat.x || y!=p_quat.y || z!=p_quat.z || w!=p_quat.w;
+bool Quat::operator!=(const Quat &p_quat) const {
+	return x != p_quat.x || y != p_quat.y || z != p_quat.z || w != p_quat.w;
 }
 
-}
+} // namespace godot

src/core/RID.cpp

@@ -6,50 +6,40 @@
 
 namespace godot {
 
-RID::RID()
-{
+RID::RID() {
 	godot::api->godot_rid_new(&_godot_rid);
 }
 
-RID::RID(Object *p)
-{
-	godot::api->godot_rid_new_with_resource(&_godot_rid, (const godot_object *) p);
+RID::RID(Object *p) {
+	godot::api->godot_rid_new_with_resource(&_godot_rid, (const godot_object *)p);
 }
 
-int32_t RID::get_rid() const
-{
+int32_t RID::get_rid() const {
 	return godot::api->godot_rid_get_id(&_godot_rid);
 }
 
-bool RID::operator==(const RID & p_other) const
-{
+bool RID::operator==(const RID &p_other) const {
 	return godot::api->godot_rid_operator_equal(&_godot_rid, &p_other._godot_rid);
 }
 
-bool RID::operator!=(const RID & p_other) const
-{
+bool RID::operator!=(const RID &p_other) const {
 	return !(*this == p_other);
 }
 
-bool RID::operator<(const RID & p_other) const
-{
+bool RID::operator<(const RID &p_other) const {
 	return godot::api->godot_rid_operator_less(&_godot_rid, &p_other._godot_rid);
 }
 
-bool RID::operator>(const RID & p_other) const
-{
+bool RID::operator>(const RID &p_other) const {
 	return !(*this < p_other) && *this != p_other;
 }
 
-bool RID::operator<=(const RID & p_other) const
-{
+bool RID::operator<=(const RID &p_other) const {
 	return (*this < p_other) || *this == p_other;
 }
 
-bool RID::operator>=(const RID & p_other) const
-{
+bool RID::operator>=(const RID &p_other) const {
 	return !(*this < p_other);
 }
 
-
-}
+} // namespace godot

src/core/Rect2.cpp

@@ -1,7 +1,7 @@
 #include "Rect2.hpp"
-#include "Vector2.hpp"
 #include "String.hpp"
 #include "Transform2D.hpp"
+#include "Vector2.hpp"
 
 #include <cmath>
 
@@ -15,110 +15,104 @@ namespace godot {
 #define MIN(a, b) (a < b ? a : b)
 #endif
 
+real_t Rect2::distance_to(const Vector2 &p_point) const {
 
-real_t Rect2::distance_to(const Vector2& p_point) const {
+	real_t dist = 1e20;
 
-		real_t dist = 1e20;
-
-		if (p_point.x < pos.x) {
-			dist=MIN(dist,pos.x-p_point.x);
-		}
-		if (p_point.y < pos.y) {
-			dist=MIN(dist,pos.y-p_point.y);
-		}
-		if (p_point.x >= (pos.x+size.x) ) {
-			dist=MIN(p_point.x-(pos.x+size.x),dist);
-		}
-		if (p_point.y >= (pos.y+size.y) ) {
-			dist=MIN(p_point.y-(pos.y+size.y),dist);
-		}
-
-		if (dist==1e20)
-			return 0;
-		else
-			return dist;
+	if (p_point.x < position.x) {
+		dist = MIN(dist, position.x - p_point.x);
+	}
+	if (p_point.y < position.y) {
+		dist = MIN(dist, position.y - p_point.y);
+	}
+	if (p_point.x >= (position.x + size.x)) {
+		dist = MIN(p_point.x - (position.x + size.x), dist);
+	}
+	if (p_point.y >= (position.y + size.y)) {
+		dist = MIN(p_point.y - (position.y + size.y), dist);
 	}
 
-Rect2 Rect2::clip(const Rect2& p_rect) const { /// return a clipped rect
+	if (dist == 1e20)
+		return 0;
+	else
+		return dist;
+}
 
-	Rect2 new_rect=p_rect;
+Rect2 Rect2::clip(const Rect2 &p_rect) const { /// return a clipped rect
 
-	if (!intersects( new_rect ))
+	Rect2 new_rect = p_rect;
+
+	if (!intersects(new_rect))
 		return Rect2();
 
-	new_rect.pos.x = MAX( p_rect.pos.x , pos.x );
-	new_rect.pos.y = MAX( p_rect.pos.y , pos.y );
+	new_rect.position.x = MAX(p_rect.position.x, position.x);
+	new_rect.position.y = MAX(p_rect.position.y, position.y);
 
-	Point2 p_rect_end=p_rect.pos+p_rect.size;
-	Point2 end=pos+size;
+	Point2 p_rect_end = p_rect.position + p_rect.size;
+	Point2 end = position + size;
 
-	new_rect.size.x=MIN(p_rect_end.x,end.x) - new_rect.pos.x;
-	new_rect.size.y=MIN(p_rect_end.y,end.y) - new_rect.pos.y;
+	new_rect.size.x = MIN(p_rect_end.x, end.x) - new_rect.position.x;
+	new_rect.size.y = MIN(p_rect_end.y, end.y) - new_rect.position.y;
 
 	return new_rect;
 }
 
-Rect2 Rect2::merge(const Rect2& p_rect) const { ///< return a merged rect
+Rect2 Rect2::merge(const Rect2 &p_rect) const { ///< return a merged rect
 
 	Rect2 new_rect;
 
-	new_rect.pos.x=MIN( p_rect.pos.x , pos.x );
-	new_rect.pos.y=MIN( p_rect.pos.y , pos.y );
+	new_rect.position.x = MIN(p_rect.position.x, position.x);
+	new_rect.position.y = MIN(p_rect.position.y, position.y);
 
+	new_rect.size.x = MAX(p_rect.position.x + p_rect.size.x, position.x + size.x);
+	new_rect.size.y = MAX(p_rect.position.y + p_rect.size.y, position.y + size.y);
 
-	new_rect.size.x = MAX( p_rect.pos.x+p_rect.size.x , pos.x+size.x );
-	new_rect.size.y = MAX( p_rect.pos.y+p_rect.size.y , pos.y+size.y );
-
-	new_rect.size = new_rect.size - new_rect.pos; //make relative again
+	new_rect.size = new_rect.size - new_rect.position; //make relative again
 
 	return new_rect;
 }
 
-
-
-Rect2::operator String() const
-{
-	return String(pos)+", "+String(size);
+Rect2::operator String() const {
+	return String(position) + ", " + String(size);
 }
 
+bool Rect2::intersects_segment(const Point2 &p_from, const Point2 &p_to, Point2 *r_position, Point2 *r_normal) const {
 
-bool Rect2::intersects_segment(const Point2& p_from, const Point2& p_to, Point2* r_pos,Point2* r_normal) const {
+	real_t min = 0, max = 1;
+	int axis = 0;
+	real_t sign = 0;
 
-	real_t min=0,max=1;
-	int axis=0;
-	real_t sign=0;
-
-	for(int i=0;i<2;i++) {
-		real_t seg_from=p_from[i];
-		real_t seg_to=p_to[i];
-		real_t box_begin=pos[i];
-		real_t box_end=box_begin+size[i];
-		real_t cmin,cmax;
+	for (int i = 0; i < 2; i++) {
+		real_t seg_from = p_from[i];
+		real_t seg_to = p_to[i];
+		real_t box_begin = position[i];
+		real_t box_end = box_begin + size[i];
+		real_t cmin, cmax;
 		real_t csign;
 
 		if (seg_from < seg_to) {
 
 			if (seg_from > box_end || seg_to < box_begin)
 				return false;
-			real_t length=seg_to-seg_from;
-			cmin = (seg_from < box_begin)?((box_begin - seg_from)/length):0;
-			cmax = (seg_to > box_end)?((box_end - seg_from)/length):1;
-			csign=-1.0;
+			real_t length = seg_to - seg_from;
+			cmin = (seg_from < box_begin) ? ((box_begin - seg_from) / length) : 0;
+			cmax = (seg_to > box_end) ? ((box_end - seg_from) / length) : 1;
+			csign = -1.0;
 
 		} else {
 
 			if (seg_to > box_end || seg_from < box_begin)
 				return false;
-			real_t length=seg_to-seg_from;
-			cmin = (seg_from > box_end)?(box_end - seg_from)/length:0;
-			cmax = (seg_to < box_begin)?(box_begin - seg_from)/length:1;
-			csign=1.0;
+			real_t length = seg_to - seg_from;
+			cmin = (seg_from > box_end) ? (box_end - seg_from) / length : 0;
+			cmax = (seg_to < box_begin) ? (box_begin - seg_from) / length : 1;
+			csign = 1.0;
 		}
 
 		if (cmin > min) {
 			min = cmin;
-			axis=i;
-			sign=csign;
+			axis = i;
+			sign = csign;
 		}
 		if (cmax < max)
 			max = cmax;
@@ -126,175 +120,169 @@ bool Rect2::intersects_segment(const Point2& p_from, const Point2& p_to, Point2*
 			return false;
 	}
 
-
-	Vector2 rel=p_to-p_from;
+	Vector2 rel = p_to - p_from;
 
 	if (r_normal) {
 		Vector2 normal;
-		normal[axis]=sign;
-		*r_normal=normal;
+		normal[axis] = sign;
+		*r_normal = normal;
 	}
 
-	if (r_pos)
-		*r_pos=p_from+rel*min;
+	if (r_position)
+		*r_position = p_from + rel * min;
 
 	return true;
 }
 
-
-bool Rect2::intersects_transformed(const Transform2D& p_xform, const Rect2& p_rect) const {
+bool Rect2::intersects_transformed(const Transform2D &p_xform, const Rect2 &p_rect) const {
 
 	//SAT intersection between local and transformed rect2
 
-	Vector2 xf_points[4]={
-		p_xform.xform(p_rect.pos),
-		p_xform.xform(Vector2(p_rect.pos.x+p_rect.size.x,p_rect.pos.y)),
-		p_xform.xform(Vector2(p_rect.pos.x,p_rect.pos.y+p_rect.size.y)),
-		p_xform.xform(Vector2(p_rect.pos.x+p_rect.size.x,p_rect.pos.y+p_rect.size.y)),
+	Vector2 xf_points[4] = {
+		p_xform.xform(p_rect.position),
+		p_xform.xform(Vector2(p_rect.position.x + p_rect.size.x, p_rect.position.y)),
+		p_xform.xform(Vector2(p_rect.position.x, p_rect.position.y + p_rect.size.y)),
+		p_xform.xform(Vector2(p_rect.position.x + p_rect.size.x, p_rect.position.y + p_rect.size.y)),
 	};
 
 	real_t low_limit;
 
 	//base rect2 first (faster)
 
-	if (xf_points[0].y>pos.y)
+	if (xf_points[0].y > position.y)
 		goto next1;
-	if (xf_points[1].y>pos.y)
+	if (xf_points[1].y > position.y)
 		goto next1;
-	if (xf_points[2].y>pos.y)
+	if (xf_points[2].y > position.y)
 		goto next1;
-	if (xf_points[3].y>pos.y)
+	if (xf_points[3].y > position.y)
 		goto next1;
 
 	return false;
 
-	next1:
+next1:
 
-	low_limit=pos.y+size.y;
+	low_limit = position.y + size.y;
 
-	if (xf_points[0].y<low_limit)
+	if (xf_points[0].y < low_limit)
 		goto next2;
-	if (xf_points[1].y<low_limit)
+	if (xf_points[1].y < low_limit)
 		goto next2;
-	if (xf_points[2].y<low_limit)
+	if (xf_points[2].y < low_limit)
 		goto next2;
-	if (xf_points[3].y<low_limit)
+	if (xf_points[3].y < low_limit)
 		goto next2;
 
 	return false;
 
-	next2:
+next2:
 
-	if (xf_points[0].x>pos.x)
+	if (xf_points[0].x > position.x)
 		goto next3;
-	if (xf_points[1].x>pos.x)
+	if (xf_points[1].x > position.x)
 		goto next3;
-	if (xf_points[2].x>pos.x)
+	if (xf_points[2].x > position.x)
 		goto next3;
-	if (xf_points[3].x>pos.x)
+	if (xf_points[3].x > position.x)
 		goto next3;
 
 	return false;
 
-	next3:
+next3:
 
-	low_limit=pos.x+size.x;
+	low_limit = position.x + size.x;
 
-	if (xf_points[0].x<low_limit)
+	if (xf_points[0].x < low_limit)
 		goto next4;
-	if (xf_points[1].x<low_limit)
+	if (xf_points[1].x < low_limit)
 		goto next4;
-	if (xf_points[2].x<low_limit)
+	if (xf_points[2].x < low_limit)
 		goto next4;
-	if (xf_points[3].x<low_limit)
+	if (xf_points[3].x < low_limit)
 		goto next4;
 
 	return false;
 
-	next4:
+next4:
 
-	Vector2 xf_points2[4]={
-		pos,
-		Vector2(pos.x+size.x,pos.y),
-		Vector2(pos.x,pos.y+size.y),
-		Vector2(pos.x+size.x,pos.y+size.y),
+	Vector2 xf_points2[4] = {
+		position,
+		Vector2(position.x + size.x, position.y),
+		Vector2(position.x, position.y + size.y),
+		Vector2(position.x + size.x, position.y + size.y),
 	};
 
-	real_t maxa=p_xform.elements[0].dot(xf_points2[0]);
-	real_t mina=maxa;
+	real_t maxa = p_xform.elements[0].dot(xf_points2[0]);
+	real_t mina = maxa;
 
 	real_t dp = p_xform.elements[0].dot(xf_points2[1]);
-	maxa=MAX(dp,maxa);
-	mina=MIN(dp,mina);
+	maxa = MAX(dp, maxa);
+	mina = MIN(dp, mina);
 
 	dp = p_xform.elements[0].dot(xf_points2[2]);
-	maxa=MAX(dp,maxa);
-	mina=MIN(dp,mina);
+	maxa = MAX(dp, maxa);
+	mina = MIN(dp, mina);
 
 	dp = p_xform.elements[0].dot(xf_points2[3]);
-	maxa=MAX(dp,maxa);
-	mina=MIN(dp,mina);
+	maxa = MAX(dp, maxa);
+	mina = MIN(dp, mina);
 
-	real_t maxb=p_xform.elements[0].dot(xf_points[0]);
-	real_t minb=maxb;
+	real_t maxb = p_xform.elements[0].dot(xf_points[0]);
+	real_t minb = maxb;
 
 	dp = p_xform.elements[0].dot(xf_points[1]);
-	maxb=MAX(dp,maxb);
-	minb=MIN(dp,minb);
+	maxb = MAX(dp, maxb);
+	minb = MIN(dp, minb);
 
 	dp = p_xform.elements[0].dot(xf_points[2]);
-	maxb=MAX(dp,maxb);
-	minb=MIN(dp,minb);
+	maxb = MAX(dp, maxb);
+	minb = MIN(dp, minb);
 
 	dp = p_xform.elements[0].dot(xf_points[3]);
-	maxb=MAX(dp,maxb);
-	minb=MIN(dp,minb);
+	maxb = MAX(dp, maxb);
+	minb = MIN(dp, minb);
 
-
-	if ( mina > maxb )
+	if (mina > maxb)
 		return false;
-	if ( minb > maxa  )
+	if (minb > maxa)
 		return false;
 
-	maxa=p_xform.elements[1].dot(xf_points2[0]);
-	mina=maxa;
+	maxa = p_xform.elements[1].dot(xf_points2[0]);
+	mina = maxa;
 
 	dp = p_xform.elements[1].dot(xf_points2[1]);
-	maxa=MAX(dp,maxa);
-	mina=MIN(dp,mina);
+	maxa = MAX(dp, maxa);
+	mina = MIN(dp, mina);
 
 	dp = p_xform.elements[1].dot(xf_points2[2]);
-	maxa=MAX(dp,maxa);
-	mina=MIN(dp,mina);
+	maxa = MAX(dp, maxa);
+	mina = MIN(dp, mina);
 
 	dp = p_xform.elements[1].dot(xf_points2[3]);
-	maxa=MAX(dp,maxa);
-	mina=MIN(dp,mina);
+	maxa = MAX(dp, maxa);
+	mina = MIN(dp, mina);
 
-	maxb=p_xform.elements[1].dot(xf_points[0]);
-	minb=maxb;
+	maxb = p_xform.elements[1].dot(xf_points[0]);
+	minb = maxb;
 
 	dp = p_xform.elements[1].dot(xf_points[1]);
-	maxb=MAX(dp,maxb);
-	minb=MIN(dp,minb);
+	maxb = MAX(dp, maxb);
+	minb = MIN(dp, minb);
 
 	dp = p_xform.elements[1].dot(xf_points[2]);
-	maxb=MAX(dp,maxb);
-	minb=MIN(dp,minb);
+	maxb = MAX(dp, maxb);
+	minb = MIN(dp, minb);
 
 	dp = p_xform.elements[1].dot(xf_points[3]);
-	maxb=MAX(dp,maxb);
-	minb=MIN(dp,minb);
+	maxb = MAX(dp, maxb);
+	minb = MIN(dp, minb);
 
-
-	if ( mina > maxb )
+	if (mina > maxb)
 		return false;
-	if ( minb > maxa  )
+	if (minb > maxa)
 		return false;
 
-
 	return true;
-
 }
 
-}
+} // namespace godot

src/core/String.cpp

@@ -1,10 +1,10 @@
 #include "String.hpp"
 
 #include "Array.hpp"
+#include "GodotGlobal.hpp"
 #include "NodePath.hpp"
 #include "PoolArrays.hpp"
 #include "Variant.hpp"
-#include "GodotGlobal.hpp"
 
 #include <gdnative/string.h>
 
@@ -99,7 +99,7 @@ String::~String() {
 }
 
 wchar_t &String::operator[](const int idx) {
-	return *godot::api->godot_string_operator_index(&_godot_string, idx);
+	return *const_cast<wchar_t *>(godot::api->godot_string_operator_index(&_godot_string, idx));
 }
 
 wchar_t String::operator[](const int idx) const {
@@ -169,7 +169,7 @@ char *String::alloc_c_string() const {
 
 	int length = godot::api->godot_char_string_length(&contents);
 
-	char *result = (char *) godot::api->godot_alloc(length + 1);
+	char *result = (char *)godot::api->godot_alloc(length + 1);
 
 	if (result) {
 		memcpy(result, godot::api->godot_char_string_get_data(&contents), length + 1);
@@ -219,7 +219,7 @@ bool String::begins_with_char_array(const char *p_char_array) const {
 PoolStringArray String::bigrams() const {
 	godot_array arr = godot::api->godot_string_bigrams(&_godot_string);
 
-	return *(PoolStringArray *)&arr;
+	return *(Array *)&arr;
 }
 
 String String::c_escape() const {
@@ -256,15 +256,15 @@ void String::erase(int position, int chars) {
 }
 
 int String::find(String p_what, int p_from) const {
-	return godot::api->godot_string_find(&_godot_string, p_what._godot_string);
+	return godot::api->godot_string_find_from(&_godot_string, p_what._godot_string, p_from);
 }
 
-int String::find_last(String what) const {
-	return godot::api->godot_string_find_last(&_godot_string, what._godot_string);
+int String::find_last(String p_what) const {
+	return godot::api->godot_string_find_last(&_godot_string, p_what._godot_string);
 }
 
-int String::findn(String what, int from) const {
-	return godot::api->godot_string_findn(&_godot_string, what._godot_string);
+int String::findn(String p_what, int p_from) const {
+	return godot::api->godot_string_findn_from(&_godot_string, p_what._godot_string, p_from);
 }
 
 String String::format(Variant values) const {
@@ -443,13 +443,12 @@ String String::replacen(String what, String forwhat) const {
 	return new_string;
 }
 
-int String::rfind(String what, int from) const {
-	return godot::api->godot_string_rfind(&_godot_string, what._godot_string);
+int String::rfind(String p_what, int p_from) const {
+	return godot::api->godot_string_rfind_from(&_godot_string, p_what._godot_string, p_from);
 }
 
-int String::rfindn(String what, int from) const {
-	// From -1
-	return godot::api->godot_string_rfindn(&_godot_string, what._godot_string);
+int String::rfindn(String p_what, int p_from) const {
+	return godot::api->godot_string_rfindn_from(&_godot_string, p_what._godot_string, p_from);
 }
 
 String String::right(int position) const {
@@ -479,13 +478,19 @@ float String::similarity(String text) const {
 PoolStringArray String::split(String divisor, bool allow_empty) const {
 	godot_array arr = godot::api->godot_string_split(&_godot_string, &divisor._godot_string);
 
-	return *(PoolStringArray *)&arr;
+	return *(Array *)&arr;
+}
+
+PoolIntArray String::split_ints(String divisor, bool allow_empty) const {
+	godot_array arr = godot::api->godot_string_split_floats(&_godot_string, &divisor._godot_string);
+
+	return *(Array *)&arr;
 }
 
 PoolRealArray String::split_floats(String divisor, bool allow_empty) const {
 	godot_array arr = godot::api->godot_string_split_floats(&_godot_string, &divisor._godot_string);
 
-	return *(PoolRealArray *)&arr;
+	return *(Array *)&arr;
 }
 
 String String::strip_edges(bool left, bool right) const {
@@ -537,4 +542,17 @@ String String::xml_unescape() const {
 
 	return new_string;
 }
+
+signed char String::casecmp_to(String p_str) const {
+	return godot::api->godot_string_casecmp_to(&_godot_string, &p_str._godot_string);
 }
+
+signed char String::nocasecmp_to(String p_str) const {
+	return godot::api->godot_string_nocasecmp_to(&_godot_string, &p_str._godot_string);
+}
+
+signed char String::naturalnocasecmp_to(String p_str) const {
+	return godot::api->godot_string_naturalnocasecmp_to(&_godot_string, &p_str._godot_string);
+}
+
+} // namespace godot

src/core/TagDB.cpp

@@ -0,0 +1,50 @@
+#include "TagDB.hpp"
+
+#include <unordered_map>
+
+#include <GodotGlobal.hpp>
+
+namespace godot {
+
+namespace _TagDB {
+
+std::unordered_map<size_t, size_t> parent_to;
+
+void register_type(size_t type_tag, size_t base_type_tag) {
+	if (type_tag == base_type_tag) {
+		return;
+	}
+	parent_to[type_tag] = base_type_tag;
+}
+
+bool is_type_known(size_t type_tag) {
+	return parent_to.find(type_tag) != parent_to.end();
+}
+
+void register_global_type(const char *name, size_t type_tag, size_t base_type_tag) {
+
+	godot::nativescript_1_1_api->godot_nativescript_set_global_type_tag(godot::_RegisterState::language_index, name, (const void *)type_tag);
+
+	register_type(type_tag, base_type_tag);
+}
+
+bool is_type_compatible(size_t ask_tag, size_t have_tag) {
+
+	if (have_tag == 0)
+		return false;
+
+	size_t tag = have_tag;
+
+	while (tag != 0) {
+		if (tag == ask_tag)
+			return true;
+
+		tag = parent_to[tag];
+	}
+
+	return false;
+}
+
+} // namespace _TagDB
+
+} // namespace godot

src/core/Transform.cpp

@@ -2,134 +2,122 @@
 
 #include "Basis.hpp"
 
-#include "Plane.hpp"
 #include "AABB.hpp"
+#include "Plane.hpp"
 
 #include "Quat.hpp"
 
 namespace godot {
 
-
-
-Transform Transform::inverse_xform(const Transform& t) const {
+Transform Transform::inverse_xform(const Transform &t) const {
 
 	Vector3 v = t.origin - origin;
 	return Transform(basis.transpose_xform(t.basis),
-		basis.xform(v));
+			basis.xform(v));
 }
 
-void Transform::set(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz,real_t tx, real_t ty, real_t tz) {
+void Transform::set(real_t xx, real_t xy, real_t xz, real_t yx, real_t yy, real_t yz, real_t zx, real_t zy, real_t zz, real_t tx, real_t ty, real_t tz) {
 
-	basis.elements[0][0]=xx;
-	basis.elements[0][1]=xy;
-	basis.elements[0][2]=xz;
-	basis.elements[1][0]=yx;
-	basis.elements[1][1]=yy;
-	basis.elements[1][2]=yz;
-	basis.elements[2][0]=zx;
-	basis.elements[2][1]=zy;
-	basis.elements[2][2]=zz;
-	origin.x=tx;
-	origin.y=ty;
-	origin.z=tz;
+	basis.elements[0][0] = xx;
+	basis.elements[0][1] = xy;
+	basis.elements[0][2] = xz;
+	basis.elements[1][0] = yx;
+	basis.elements[1][1] = yy;
+	basis.elements[1][2] = yz;
+	basis.elements[2][0] = zx;
+	basis.elements[2][1] = zy;
+	basis.elements[2][2] = zz;
+	origin.x = tx;
+	origin.y = ty;
+	origin.z = tz;
 }
 
-
-
-Vector3 Transform::xform(const Vector3& p_vector) const {
+Vector3 Transform::xform(const Vector3 &p_vector) const {
 
 	return Vector3(
-		basis[0].dot(p_vector)+origin.x,
-		basis[1].dot(p_vector)+origin.y,
-		basis[2].dot(p_vector)+origin.z
-	);
+			basis[0].dot(p_vector) + origin.x,
+			basis[1].dot(p_vector) + origin.y,
+			basis[2].dot(p_vector) + origin.z);
 }
-Vector3 Transform::xform_inv(const Vector3& p_vector) const {
+Vector3 Transform::xform_inv(const Vector3 &p_vector) const {
 
 	Vector3 v = p_vector - origin;
 
 	return Vector3(
-		(basis.elements[0][0]*v.x ) + ( basis.elements[1][0]*v.y ) + ( basis.elements[2][0]*v.z ),
-		(basis.elements[0][1]*v.x ) + ( basis.elements[1][1]*v.y ) + ( basis.elements[2][1]*v.z ),
-		(basis.elements[0][2]*v.x ) + ( basis.elements[1][2]*v.y ) + ( basis.elements[2][2]*v.z )
-	);
+			(basis.elements[0][0] * v.x) + (basis.elements[1][0] * v.y) + (basis.elements[2][0] * v.z),
+			(basis.elements[0][1] * v.x) + (basis.elements[1][1] * v.y) + (basis.elements[2][1] * v.z),
+			(basis.elements[0][2] * v.x) + (basis.elements[1][2] * v.y) + (basis.elements[2][2] * v.z));
 }
 
-Plane Transform::xform(const Plane& p_plane) const {
+Plane Transform::xform(const Plane &p_plane) const {
 
+	Vector3 point = p_plane.normal * p_plane.d;
+	Vector3 point_dir = point + p_plane.normal;
+	point = xform(point);
+	point_dir = xform(point_dir);
 
-	Vector3 point=p_plane.normal*p_plane.d;
-	Vector3 point_dir=point+p_plane.normal;
-	point=xform(point);
-	point_dir=xform(point_dir);
-
-	Vector3 normal=point_dir-point;
+	Vector3 normal = point_dir - point;
 	normal.normalize();
-	real_t d=normal.dot(point);
-
-	return Plane(normal,d);
+	real_t d = normal.dot(point);
 
+	return Plane(normal, d);
 }
-Plane Transform::xform_inv(const Plane& p_plane) const {
+Plane Transform::xform_inv(const Plane &p_plane) const {
 
-	Vector3 point=p_plane.normal*p_plane.d;
-	Vector3 point_dir=point+p_plane.normal;
-	xform_inv(point);
-	xform_inv(point_dir);
+	Vector3 point = p_plane.normal * p_plane.d;
+	Vector3 point_dir = point + p_plane.normal;
+	point = xform_inv(point);
+	point_dir = xform_inv(point_dir);
 
-	Vector3 normal=point_dir-point;
+	Vector3 normal = point_dir - point;
 	normal.normalize();
-	real_t d=normal.dot(point);
-
-	return Plane(normal,d);
+	real_t d = normal.dot(point);
 
+	return Plane(normal, d);
 }
 
-AABB Transform::xform(const AABB& p_aabb) const {
+AABB Transform::xform(const AABB &p_aabb) const {
 	/* define vertices */
-	Vector3 x=basis.get_axis(0)*p_aabb.size.x;
-	Vector3 y=basis.get_axis(1)*p_aabb.size.y;
-	Vector3 z=basis.get_axis(2)*p_aabb.size.z;
-	Vector3 pos = xform( p_aabb.position );
-//could be even further optimized
+	Vector3 x = basis.get_axis(0) * p_aabb.size.x;
+	Vector3 y = basis.get_axis(1) * p_aabb.size.y;
+	Vector3 z = basis.get_axis(2) * p_aabb.size.z;
+	Vector3 pos = xform(p_aabb.position);
+	//could be even further optimized
 	AABB new_aabb;
-	new_aabb.position=pos;
-	new_aabb.expand_to( pos+x );
-	new_aabb.expand_to( pos+y );
-	new_aabb.expand_to( pos+z );
-	new_aabb.expand_to( pos+x+y );
-	new_aabb.expand_to( pos+x+z );
-	new_aabb.expand_to( pos+y+z );
-	new_aabb.expand_to( pos+x+y+z );
+	new_aabb.position = pos;
+	new_aabb.expand_to(pos + x);
+	new_aabb.expand_to(pos + y);
+	new_aabb.expand_to(pos + z);
+	new_aabb.expand_to(pos + x + y);
+	new_aabb.expand_to(pos + x + z);
+	new_aabb.expand_to(pos + y + z);
+	new_aabb.expand_to(pos + x + y + z);
 	return new_aabb;
-
 }
-AABB Transform::xform_inv(const AABB& p_aabb) const {
+AABB Transform::xform_inv(const AABB &p_aabb) const {
 
 	/* define vertices */
-	Vector3 vertices[8]={
-			Vector3(p_aabb.position.x+p_aabb.size.x,	p_aabb.position.y+p_aabb.size.y,	p_aabb.position.z+p_aabb.size.z),
-			Vector3(p_aabb.position.x+p_aabb.size.x,	p_aabb.position.y+p_aabb.size.y,	p_aabb.position.z),
-			Vector3(p_aabb.position.x+p_aabb.size.x,	p_aabb.position.y,		p_aabb.position.z+p_aabb.size.z),
-			Vector3(p_aabb.position.x+p_aabb.size.x,	p_aabb.position.y,		p_aabb.position.z),
-			Vector3(p_aabb.position.x,	p_aabb.position.y+p_aabb.size.y,	p_aabb.position.z+p_aabb.size.z),
-			Vector3(p_aabb.position.x,	p_aabb.position.y+p_aabb.size.y,	p_aabb.position.z),
-			Vector3(p_aabb.position.x,	p_aabb.position.y,		p_aabb.position.z+p_aabb.size.z),
-			Vector3(p_aabb.position.x,	p_aabb.position.y,		p_aabb.position.z)
+	Vector3 vertices[8] = {
+		Vector3(p_aabb.position.x + p_aabb.size.x, p_aabb.position.y + p_aabb.size.y, p_aabb.position.z + p_aabb.size.z),
+		Vector3(p_aabb.position.x + p_aabb.size.x, p_aabb.position.y + p_aabb.size.y, p_aabb.position.z),
+		Vector3(p_aabb.position.x + p_aabb.size.x, p_aabb.position.y, p_aabb.position.z + p_aabb.size.z),
+		Vector3(p_aabb.position.x + p_aabb.size.x, p_aabb.position.y, p_aabb.position.z),
+		Vector3(p_aabb.position.x, p_aabb.position.y + p_aabb.size.y, p_aabb.position.z + p_aabb.size.z),
+		Vector3(p_aabb.position.x, p_aabb.position.y + p_aabb.size.y, p_aabb.position.z),
+		Vector3(p_aabb.position.x, p_aabb.position.y, p_aabb.position.z + p_aabb.size.z),
+		Vector3(p_aabb.position.x, p_aabb.position.y, p_aabb.position.z)
 	};
 
-
 	AABB ret;
 
-	ret.position=xform_inv(vertices[0]);
+	ret.position = xform_inv(vertices[0]);
 
-	for (int i=1;i<8;i++) {
+	for (int i = 1; i < 8; i++) {
 
-		ret.expand_to( xform_inv(vertices[i]) );
+		ret.expand_to(xform_inv(vertices[i]));
 	}
 
 	return ret;
-
 }
 
 void Transform::affine_invert() {
@@ -140,13 +128,11 @@ void Transform::affine_invert() {
 
 Transform Transform::affine_inverse() const {
 
-	Transform ret=*this;
+	Transform ret = *this;
 	ret.affine_invert();
 	return ret;
-
 }
 
-
 void Transform::invert() {
 
 	basis.transpose();
@@ -156,35 +142,34 @@ void Transform::invert() {
 Transform Transform::inverse() const {
 	// FIXME: this function assumes the basis is a rotation matrix, with no scaling.
 	// Transform::affine_inverse can handle matrices with scaling, so GDScript should eventually use that.
-	Transform ret=*this;
+	Transform ret = *this;
 	ret.invert();
 	return ret;
 }
 
-
-void Transform::rotate(const Vector3& p_axis,real_t p_phi) {
+void Transform::rotate(const Vector3 &p_axis, real_t p_phi) {
 
 	*this = rotated(p_axis, p_phi);
 }
 
-Transform Transform::rotated(const Vector3& p_axis,real_t p_phi) const{
+Transform Transform::rotated(const Vector3 &p_axis, real_t p_phi) const {
 
-	return Transform(Basis( p_axis, p_phi ), Vector3()) * (*this);
+	return Transform(Basis(p_axis, p_phi), Vector3()) * (*this);
 }
 
-void Transform::rotate_basis(const Vector3& p_axis,real_t p_phi) {
+void Transform::rotate_basis(const Vector3 &p_axis, real_t p_phi) {
 
-	basis.rotate(p_axis,p_phi);
+	basis.rotate(p_axis, p_phi);
 }
 
-Transform Transform::looking_at( const Vector3& p_target, const Vector3& p_up ) const {
+Transform Transform::looking_at(const Vector3 &p_target, const Vector3 &p_up) const {
 
 	Transform t = *this;
-	t.set_look_at(origin,p_target,p_up);
+	t.set_look_at(origin, p_target, p_up);
 	return t;
 }
 
-void Transform::set_look_at( const Vector3& p_eye, const Vector3& p_target, const Vector3& p_up ) {
+void Transform::set_look_at(const Vector3 &p_eye, const Vector3 &p_target, const Vector3 &p_up) {
 
 	// Reference: MESA source code
 	Vector3 v_x, v_y, v_z;
@@ -198,23 +183,21 @@ void Transform::set_look_at( const Vector3& p_eye, const Vector3& p_target, cons
 
 	v_y = p_up;
 
-
-	v_x=v_y.cross(v_z);
+	v_x = v_y.cross(v_z);
 
 	/* Recompute Y = Z cross X */
-	v_y=v_z.cross(v_x);
+	v_y = v_z.cross(v_x);
 
 	v_x.normalize();
 	v_y.normalize();
 
-	basis.set_axis(0,v_x);
-	basis.set_axis(1,v_y);
-	basis.set_axis(2,v_z);
-	origin=p_eye;
-
+	basis.set_axis(0, v_x);
+	basis.set_axis(1, v_y);
+	basis.set_axis(2, v_z);
+	origin = p_eye;
 }
 
-Transform Transform::interpolate_with(const Transform& p_transform, real_t p_c) const {
+Transform Transform::interpolate_with(const Transform &p_transform, real_t p_c) const {
 
 	/* not sure if very "efficient" but good enough? */
 
@@ -227,45 +210,44 @@ Transform Transform::interpolate_with(const Transform& p_transform, real_t p_c)
 	Vector3 dst_loc = p_transform.origin;
 
 	Transform dst;
-	dst.basis=src_rot.slerp(dst_rot,p_c);
-	dst.basis.scale(src_scale.linear_interpolate(dst_scale,p_c));
-	dst.origin=src_loc.linear_interpolate(dst_loc,p_c);
+	dst.basis = src_rot.slerp(dst_rot, p_c);
+	dst.basis.scale(src_scale.linear_interpolate(dst_scale, p_c));
+	dst.origin = src_loc.linear_interpolate(dst_loc, p_c);
 
 	return dst;
 }
 
-void Transform::scale(const Vector3& p_scale) {
+void Transform::scale(const Vector3 &p_scale) {
 
 	basis.scale(p_scale);
-	origin*=p_scale;
+	origin *= p_scale;
 }
 
-Transform Transform::scaled(const Vector3& p_scale) const {
+Transform Transform::scaled(const Vector3 &p_scale) const {
 
 	Transform t = *this;
 	t.scale(p_scale);
 	return t;
 }
 
-void Transform::scale_basis(const Vector3& p_scale) {
+void Transform::scale_basis(const Vector3 &p_scale) {
 
 	basis.scale(p_scale);
 }
 
-void Transform::translate( real_t p_tx, real_t p_ty, real_t p_tz)  {
-	translate( Vector3(p_tx,p_ty,p_tz) );
-
+void Transform::translate(real_t p_tx, real_t p_ty, real_t p_tz) {
+	translate(Vector3(p_tx, p_ty, p_tz));
 }
-void Transform::translate( const Vector3& p_translation ) {
+void Transform::translate(const Vector3 &p_translation) {
 
-	for( int i = 0; i < 3; i++ ) {
+	for (int i = 0; i < 3; i++) {
 		origin[i] += basis[i].dot(p_translation);
 	}
 }
 
-Transform Transform::translated( const Vector3& p_translation ) const {
+Transform Transform::translated(const Vector3 &p_translation) const {
 
-	Transform t=*this;
+	Transform t = *this;
 	t.translate(p_translation);
 	return t;
 }
@@ -282,25 +264,25 @@ Transform Transform::orthonormalized() const {
 	return _copy;
 }
 
-bool Transform::operator==(const Transform& p_transform) const {
+bool Transform::operator==(const Transform &p_transform) const {
 
-	return (basis==p_transform.basis && origin==p_transform.origin);
+	return (basis == p_transform.basis && origin == p_transform.origin);
 }
-bool Transform::operator!=(const Transform& p_transform) const {
+bool Transform::operator!=(const Transform &p_transform) const {
 
-	return (basis!=p_transform.basis || origin!=p_transform.origin);
+	return (basis != p_transform.basis || origin != p_transform.origin);
 }
 
-void Transform::operator*=(const Transform& p_transform) {
+void Transform::operator*=(const Transform &p_transform) {
 
-	origin=xform(p_transform.origin);
-	basis*=p_transform.basis;
+	origin = xform(p_transform.origin);
+	basis *= p_transform.basis;
 }
 
-Transform Transform::operator*(const Transform& p_transform) const {
+Transform Transform::operator*(const Transform &p_transform) const {
 
-	Transform t=*this;
-	t*=p_transform;
+	Transform t = *this;
+	t *= p_transform;
 	return t;
 }
 
@@ -309,11 +291,10 @@ Transform::operator String() const {
 	return basis.operator String() + " - " + origin.operator String();
 }
 
+Transform::Transform(const Basis &p_basis, const Vector3 &p_origin) {
 
-Transform::Transform(const Basis& p_basis, const Vector3& p_origin) {
-
-	basis=p_basis;
-	origin=p_origin;
+	basis = p_basis;
+	origin = p_origin;
 }
 
-}
+} // namespace godot

src/core/Transform2D.cpp

@@ -1,7 +1,7 @@
 #include "Transform2D.hpp"
-#include "Vector2.hpp"
-#include "String.hpp"
 #include "Rect2.hpp"
+#include "String.hpp"
+#include "Vector2.hpp"
 
 #include <algorithm>
 
@@ -17,75 +17,68 @@ Transform2D::Transform2D(real_t xx, real_t xy, real_t yx, real_t yy, real_t ox,
 	elements[2][1] = oy;
 }
 
-
-
-Vector2 Transform2D::basis_xform(const Vector2& v) const {
+Vector2 Transform2D::basis_xform(const Vector2 &v) const {
 
 	return Vector2(
-		tdotx(v),
-		tdoty(v)
-	);
+			tdotx(v),
+			tdoty(v));
 }
 
-Vector2 Transform2D::basis_xform_inv(const Vector2& v) const{
+Vector2 Transform2D::basis_xform_inv(const Vector2 &v) const {
 
 	return Vector2(
-		elements[0].dot(v),
-		elements[1].dot(v)
-	);
+			elements[0].dot(v),
+			elements[1].dot(v));
 }
 
-Vector2 Transform2D::xform(const Vector2& v) const {
+Vector2 Transform2D::xform(const Vector2 &v) const {
 
 	return Vector2(
-		tdotx(v),
-		tdoty(v)
-	) + elements[2];
+				   tdotx(v),
+				   tdoty(v)) +
+		   elements[2];
 }
-Vector2 Transform2D::xform_inv(const Vector2& p_vec) const {
+Vector2 Transform2D::xform_inv(const Vector2 &p_vec) const {
 
 	Vector2 v = p_vec - elements[2];
 
 	return Vector2(
-		elements[0].dot(v),
-		elements[1].dot(v)
-	);
-
+			elements[0].dot(v),
+			elements[1].dot(v));
 }
-Rect2 Transform2D::xform(const Rect2& p_rect) const {
+Rect2 Transform2D::xform(const Rect2 &p_rect) const {
 
-	Vector2 x=elements[0]*p_rect.size.x;
-	Vector2 y=elements[1]*p_rect.size.y;
-	Vector2 pos = xform( p_rect.pos );
+	Vector2 x = elements[0] * p_rect.size.x;
+	Vector2 y = elements[1] * p_rect.size.y;
+	Vector2 position = xform(p_rect.position);
 
 	Rect2 new_rect;
-	new_rect.pos=pos;
-	new_rect.expand_to( pos+x );
-	new_rect.expand_to( pos+y );
-	new_rect.expand_to( pos+x+y );
+	new_rect.position = position;
+	new_rect.expand_to(position + x);
+	new_rect.expand_to(position + y);
+	new_rect.expand_to(position + x + y);
 	return new_rect;
 }
 
-void Transform2D::set_rotation_and_scale(real_t p_rot,const Size2& p_scale) {
-
-	elements[0][0]=::cos(p_rot)*p_scale.x;
-	elements[1][1]=::cos(p_rot)*p_scale.y;
-	elements[1][0]=-::sin(p_rot)*p_scale.y;
-	elements[0][1]=::sin(p_rot)*p_scale.x;
+void Transform2D::set_rotation_and_scale(real_t p_rot, const Size2 &p_scale) {
 
+	elements[0][0] = ::cos(p_rot) * p_scale.x;
+	elements[1][1] = ::cos(p_rot) * p_scale.y;
+	elements[1][0] = -::sin(p_rot) * p_scale.y;
+	elements[0][1] = ::sin(p_rot) * p_scale.x;
 }
 
-Rect2 Transform2D::xform_inv(const Rect2& p_rect) const {
+Rect2 Transform2D::xform_inv(const Rect2 &p_rect) const {
 
-	Vector2 ends[4]={
-		xform_inv( p_rect.pos ),
-		xform_inv( Vector2(p_rect.pos.x,p_rect.pos.y+p_rect.size.y ) ),
-		xform_inv( Vector2(p_rect.pos.x+p_rect.size.x,p_rect.pos.y+p_rect.size.y ) ),
-		xform_inv( Vector2(p_rect.pos.x+p_rect.size.x,p_rect.pos.y ) )
+	Vector2 ends[4] = {
+		xform_inv(p_rect.position),
+		xform_inv(Vector2(p_rect.position.x, p_rect.position.y + p_rect.size.y)),
+		xform_inv(Vector2(p_rect.position.x + p_rect.size.x, p_rect.position.y + p_rect.size.y)),
+		xform_inv(Vector2(p_rect.position.x + p_rect.size.x, p_rect.position.y))
 	};
 
 	Rect2 new_rect;
-	new_rect.pos=ends[0];
+	new_rect.position = ends[0];
 	new_rect.expand_to(ends[1]);
 	new_rect.expand_to(ends[2]);
 	new_rect.expand_to(ends[3]);
@@ -96,205 +89,194 @@ Rect2 Transform2D::xform_inv(const Rect2& p_rect) const {
 void Transform2D::invert() {
 	// FIXME: this function assumes the basis is a rotation matrix, with no scaling.
 	// Transform2D::affine_inverse can handle matrices with scaling, so GDScript should eventually use that.
-	std::swap(elements[0][1],elements[1][0]);
+	std::swap(elements[0][1], elements[1][0]);
 	elements[2] = basis_xform(-elements[2]);
 }
 
 Transform2D Transform2D::inverse() const {
 
-	Transform2D inv=*this;
+	Transform2D inv = *this;
 	inv.invert();
 	return inv;
-
 }
 
 void Transform2D::affine_invert() {
 
 	real_t det = basis_determinant();
-	ERR_FAIL_COND(det==0);
+	ERR_FAIL_COND(det == 0);
 	real_t idet = 1.0 / det;
 
-	std::swap( elements[0][0],elements[1][1] );
-	elements[0]*=Vector2(idet,-idet);
-	elements[1]*=Vector2(-idet,idet);
+	std::swap(elements[0][0], elements[1][1]);
+	elements[0] *= Vector2(idet, -idet);
+	elements[1] *= Vector2(-idet, idet);
 
 	elements[2] = basis_xform(-elements[2]);
-
 }
 
 Transform2D Transform2D::affine_inverse() const {
 
-	Transform2D inv=*this;
+	Transform2D inv = *this;
 	inv.affine_invert();
 	return inv;
 }
 
 void Transform2D::rotate(real_t p_phi) {
-	*this = Transform2D(p_phi,Vector2()) * (*this);
+	*this = Transform2D(p_phi, Vector2()) * (*this);
 }
 
 real_t Transform2D::get_rotation() const {
 	real_t det = basis_determinant();
 	Transform2D m = orthonormalized();
 	if (det < 0) {
-		m.scale_basis(Size2(-1,-1));
+		m.scale_basis(Size2(-1, -1));
 	}
-	return ::atan2(m[0].y,m[0].x);
+	return ::atan2(m[0].y, m[0].x);
 }
 
 void Transform2D::set_rotation(real_t p_rot) {
 
 	real_t cr = ::cos(p_rot);
 	real_t sr = ::sin(p_rot);
-	elements[0][0]=cr;
-	elements[0][1]=sr;
-	elements[1][0]=-sr;
-	elements[1][1]=cr;
+	elements[0][0] = cr;
+	elements[0][1] = sr;
+	elements[1][0] = -sr;
+	elements[1][1] = cr;
 }
 
-Transform2D::Transform2D(real_t p_rot, const Vector2& p_pos) {
+Transform2D::Transform2D(real_t p_rot, const Vector2 &p_position) {
 
 	real_t cr = ::cos(p_rot);
 	real_t sr = ::sin(p_rot);
-	elements[0][0]=cr;
-	elements[0][1]=sr;
-	elements[1][0]=-sr;
-	elements[1][1]=cr;
-	elements[2]=p_pos;
+	elements[0][0] = cr;
+	elements[0][1] = sr;
+	elements[1][0] = -sr;
+	elements[1][1] = cr;
+	elements[2] = p_position;
 }
 
 Size2 Transform2D::get_scale() const {
 	real_t det_sign = basis_determinant() > 0 ? 1 : -1;
-	return det_sign * Size2( elements[0].length(), elements[1].length() );
+	return det_sign * Size2(elements[0].length(), elements[1].length());
 }
 
-void Transform2D::scale(const Size2& p_scale) {
+void Transform2D::scale(const Size2 &p_scale) {
 	scale_basis(p_scale);
-	elements[2]*=p_scale;
+	elements[2] *= p_scale;
 }
-void Transform2D::scale_basis(const Size2& p_scale) {
-
-	elements[0][0]*=p_scale.x;
-	elements[0][1]*=p_scale.y;
-	elements[1][0]*=p_scale.x;
-	elements[1][1]*=p_scale.y;
+void Transform2D::scale_basis(const Size2 &p_scale) {
 
+	elements[0][0] *= p_scale.x;
+	elements[0][1] *= p_scale.y;
+	elements[1][0] *= p_scale.x;
+	elements[1][1] *= p_scale.y;
 }
-void Transform2D::translate( real_t p_tx, real_t p_ty) {
+void Transform2D::translate(real_t p_tx, real_t p_ty) {
 
-	translate(Vector2(p_tx,p_ty));
+	translate(Vector2(p_tx, p_ty));
 }
-void Transform2D::translate( const Vector2& p_translation ) {
+void Transform2D::translate(const Vector2 &p_translation) {
 
-	elements[2]+=basis_xform(p_translation);
+	elements[2] += basis_xform(p_translation);
 }
 
 void Transform2D::orthonormalize() {
 
 	// Gram-Schmidt Process
 
-	Vector2 x=elements[0];
-	Vector2 y=elements[1];
+	Vector2 x = elements[0];
+	Vector2 y = elements[1];
 
 	x.normalize();
-	y = (y-x*(x.dot(y)));
+	y = (y - x * (x.dot(y)));
 	y.normalize();
 
-	elements[0]=x;
-	elements[1]=y;
+	elements[0] = x;
+	elements[1] = y;
 }
 Transform2D Transform2D::orthonormalized() const {
 
-	Transform2D on=*this;
+	Transform2D on = *this;
 	on.orthonormalize();
 	return on;
-
 }
 
-bool Transform2D::operator==(const Transform2D& p_transform) const {
+bool Transform2D::operator==(const Transform2D &p_transform) const {
 
-	for(int i=0;i<3;i++) {
-		if (elements[i]!=p_transform.elements[i])
+	for (int i = 0; i < 3; i++) {
+		if (elements[i] != p_transform.elements[i])
 			return false;
 	}
 
 	return true;
 }
 
-bool Transform2D::operator!=(const Transform2D& p_transform) const {
+bool Transform2D::operator!=(const Transform2D &p_transform) const {
 
-	for(int i=0;i<3;i++) {
-		if (elements[i]!=p_transform.elements[i])
+	for (int i = 0; i < 3; i++) {
+		if (elements[i] != p_transform.elements[i])
 			return true;
 	}
 
 	return false;
-
 }
 
-void Transform2D::operator*=(const Transform2D& p_transform) {
+void Transform2D::operator*=(const Transform2D &p_transform) {
 
 	elements[2] = xform(p_transform.elements[2]);
 
-	real_t x0,x1,y0,y1;
+	real_t x0, x1, y0, y1;
 
 	x0 = tdotx(p_transform.elements[0]);
 	x1 = tdoty(p_transform.elements[0]);
 	y0 = tdotx(p_transform.elements[1]);
 	y1 = tdoty(p_transform.elements[1]);
 
-	elements[0][0]=x0;
-	elements[0][1]=x1;
-	elements[1][0]=y0;
-	elements[1][1]=y1;
+	elements[0][0] = x0;
+	elements[0][1] = x1;
+	elements[1][0] = y0;
+	elements[1][1] = y1;
 }
 
-
-Transform2D Transform2D::operator*(const Transform2D& p_transform) const {
+Transform2D Transform2D::operator*(const Transform2D &p_transform) const {
 
 	Transform2D t = *this;
-	t*=p_transform;
+	t *= p_transform;
 	return t;
-
 }
 
-Transform2D Transform2D::scaled(const Size2& p_scale) const {
+Transform2D Transform2D::scaled(const Size2 &p_scale) const {
 
-	Transform2D copy=*this;
+	Transform2D copy = *this;
 	copy.scale(p_scale);
 	return copy;
-
 }
 
-Transform2D Transform2D::basis_scaled(const Size2& p_scale) const {
+Transform2D Transform2D::basis_scaled(const Size2 &p_scale) const {
 
-	Transform2D copy=*this;
+	Transform2D copy = *this;
 	copy.scale_basis(p_scale);
 	return copy;
-
 }
 
 Transform2D Transform2D::untranslated() const {
 
-	Transform2D copy=*this;
-	copy.elements[2]=Vector2();
+	Transform2D copy = *this;
+	copy.elements[2] = Vector2();
 	return copy;
 }
 
-Transform2D Transform2D::translated(const Vector2& p_offset) const {
+Transform2D Transform2D::translated(const Vector2 &p_offset) const {
 
-	Transform2D copy=*this;
+	Transform2D copy = *this;
 	copy.translate(p_offset);
 	return copy;
-
 }
 
 Transform2D Transform2D::rotated(real_t p_phi) const {
 
-	Transform2D copy=*this;
+	Transform2D copy = *this;
 	copy.rotate(p_phi);
 	return copy;
-
 }
 
 real_t Transform2D::basis_determinant() const {
@@ -302,7 +284,7 @@ real_t Transform2D::basis_determinant() const {
 	return elements[0].x * elements[1].y - elements[0].y * elements[1].x;
 }
 
-Transform2D Transform2D::interpolate_with(const Transform2D& p_transform, real_t p_c) const {
+Transform2D Transform2D::interpolate_with(const Transform2D &p_transform, real_t p_c) const {
 
 	//extract parameters
 	Vector2 p1 = get_origin();
@@ -327,9 +309,9 @@ Transform2D Transform2D::interpolate_with(const Transform2D& p_transform, real_t
 	if (dot > 0.9995) {
 		v = Vector2::linear_interpolate(v1, v2, p_c).normalized(); //linearly interpolate to avoid numerical precision issues
 	} else {
-		real_t angle = p_c*::acos(dot);
-		Vector2 v3 = (v2 - v1*dot).normalized();
-		v = v1*::cos(angle) + v3*::sin(angle);
+		real_t angle = p_c * ::acos(dot);
+		Vector2 v3 = (v2 - v1 * dot).normalized();
+		v = v1 * ::cos(angle) + v3 * ::sin(angle);
 	}
 
 	//construct matrix
@@ -343,4 +325,4 @@ Transform2D::operator String() const {
 	return String(String() + elements[0] + ", " + elements[1] + ", " + elements[2]);
 }
 
-}
+} // namespace godot

src/core/Variant.cpp

@@ -2,26 +2,24 @@
 
 #include <gdnative/variant.h>
 
-#include "Defs.hpp"
 #include "CoreTypes.hpp"
+#include "Defs.hpp"
 #include "GodotGlobal.hpp"
+#include "Object.hpp"
 
 #include <iostream>
 
 namespace godot {
 
-Variant::Variant()
-{
+Variant::Variant() {
 	godot::api->godot_variant_new_nil(&_godot_variant);
 }
 
-Variant::Variant(const Variant& v)
-{
+Variant::Variant(const Variant &v) {
 	godot::api->godot_variant_new_copy(&_godot_variant, &v._godot_variant);
 }
 
-Variant::Variant(bool p_bool)
-{
+Variant::Variant(bool p_bool) {
 	godot::api->godot_variant_new_bool(&_godot_variant, p_bool);
 }
 
@@ -30,408 +28,326 @@ Variant::Variant(signed int p_int) // real one
 	godot::api->godot_variant_new_int(&_godot_variant, p_int);
 }
 
-Variant::Variant(unsigned int p_int)
-{
+Variant::Variant(unsigned int p_int) {
 	godot::api->godot_variant_new_uint(&_godot_variant, p_int);
 }
 
 Variant::Variant(signed short p_short) // real one
 {
-	godot::api->godot_variant_new_int(&_godot_variant, (int) p_short);
+	godot::api->godot_variant_new_int(&_godot_variant, (int)p_short);
 }
 
-
 Variant::Variant(int64_t p_char) // real one
 {
 	godot::api->godot_variant_new_int(&_godot_variant, p_char);
 }
 
-Variant::Variant(uint64_t p_char)
-{
+Variant::Variant(uint64_t p_char) {
 	godot::api->godot_variant_new_uint(&_godot_variant, p_char);
 }
 
-Variant::Variant(float p_float)
-{
+Variant::Variant(float p_float) {
 	godot::api->godot_variant_new_real(&_godot_variant, p_float);
 }
 
-Variant::Variant(double p_double)
-{
+Variant::Variant(double p_double) {
 	godot::api->godot_variant_new_real(&_godot_variant, p_double);
 }
 
-Variant::Variant(const String& p_string)
-{
-	godot::api->godot_variant_new_string(&_godot_variant, (godot_string *) &p_string);
+Variant::Variant(const String &p_string) {
+	godot::api->godot_variant_new_string(&_godot_variant, (godot_string *)&p_string);
 }
 
-Variant::Variant(const char * const p_cstring)
-{
+Variant::Variant(const char *const p_cstring) {
 	String s = String(p_cstring);
-	godot::api->godot_variant_new_string(&_godot_variant, (godot_string *) &s);
+	godot::api->godot_variant_new_string(&_godot_variant, (godot_string *)&s);
 }
 
-Variant::Variant(const wchar_t * p_wstring)
-{
+Variant::Variant(const wchar_t *p_wstring) {
 	String s = p_wstring;
-	godot::api->godot_variant_new_string(&_godot_variant, (godot_string *) &s);
+	godot::api->godot_variant_new_string(&_godot_variant, (godot_string *)&s);
 }
 
-Variant::Variant(const Vector2& p_vector2)
-{
-	godot::api->godot_variant_new_vector2(&_godot_variant, (godot_vector2 *) &p_vector2);
+Variant::Variant(const Vector2 &p_vector2) {
+	godot::api->godot_variant_new_vector2(&_godot_variant, (godot_vector2 *)&p_vector2);
 }
 
-Variant::Variant(const Rect2& p_rect2)
-{
-	godot::api->godot_variant_new_rect2(&_godot_variant, (godot_rect2 *) &p_rect2);
+Variant::Variant(const Rect2 &p_rect2) {
+	godot::api->godot_variant_new_rect2(&_godot_variant, (godot_rect2 *)&p_rect2);
 }
 
-Variant::Variant(const Vector3& p_vector3)
-{
-	godot::api->godot_variant_new_vector3(&_godot_variant, (godot_vector3 *) &p_vector3);
+Variant::Variant(const Vector3 &p_vector3) {
+	godot::api->godot_variant_new_vector3(&_godot_variant, (godot_vector3 *)&p_vector3);
 }
 
-Variant::Variant(const Plane& p_plane)
-{
-	godot::api->godot_variant_new_plane(&_godot_variant, (godot_plane *) &p_plane);
+Variant::Variant(const Plane &p_plane) {
+	godot::api->godot_variant_new_plane(&_godot_variant, (godot_plane *)&p_plane);
 }
 
-
-Variant::Variant(const AABB& p_aabb)
-{
-	godot::api->godot_variant_new_aabb(&_godot_variant, (godot_aabb *) &p_aabb);
+Variant::Variant(const AABB &p_aabb) {
+	godot::api->godot_variant_new_aabb(&_godot_variant, (godot_aabb *)&p_aabb);
 }
 
-Variant::Variant(const Quat& p_quat)
-{
-	godot::api->godot_variant_new_quat(&_godot_variant, (godot_quat *) &p_quat);
+Variant::Variant(const Quat &p_quat) {
+	godot::api->godot_variant_new_quat(&_godot_variant, (godot_quat *)&p_quat);
 }
 
-Variant::Variant(const Basis& p_transform)
-{
-	godot::api->godot_variant_new_basis(&_godot_variant, (godot_basis *) &p_transform);
+Variant::Variant(const Basis &p_transform) {
+	godot::api->godot_variant_new_basis(&_godot_variant, (godot_basis *)&p_transform);
 }
 
-Variant::Variant(const Transform2D& p_transform)
-{
-	godot::api->godot_variant_new_transform2d(&_godot_variant, (godot_transform2d *) &p_transform);
+Variant::Variant(const Transform2D &p_transform) {
+	godot::api->godot_variant_new_transform2d(&_godot_variant, (godot_transform2d *)&p_transform);
 }
 
-Variant::Variant(const Transform& p_transform)
-{
-	godot::api->godot_variant_new_transform(&_godot_variant, (godot_transform *) &p_transform);
+Variant::Variant(const Transform &p_transform) {
+	godot::api->godot_variant_new_transform(&_godot_variant, (godot_transform *)&p_transform);
 }
 
-Variant::Variant(const Color& p_color)
-{
-	godot::api->godot_variant_new_color(&_godot_variant, (godot_color *) &p_color);
+Variant::Variant(const Color &p_color) {
+	godot::api->godot_variant_new_color(&_godot_variant, (godot_color *)&p_color);
 }
 
-Variant::Variant(const NodePath& p_path)
-{
-	godot::api->godot_variant_new_node_path(&_godot_variant, (godot_node_path *) &p_path);
+Variant::Variant(const NodePath &p_path) {
+	godot::api->godot_variant_new_node_path(&_godot_variant, (godot_node_path *)&p_path);
 }
 
-Variant::Variant(const RID& p_rid)
-{
-	godot::api->godot_variant_new_rid(&_godot_variant, (godot_rid *) &p_rid);
+Variant::Variant(const RID &p_rid) {
+	godot::api->godot_variant_new_rid(&_godot_variant, (godot_rid *)&p_rid);
 }
 
-Variant::Variant(const Object* p_object)
-{
-	godot::api->godot_variant_new_object(&_godot_variant, (godot_object *) p_object);
+Variant::Variant(const Object *p_object) {
+	if (p_object)
+		godot::api->godot_variant_new_object(&_godot_variant, p_object->_owner);
+	else
+		godot::api->godot_variant_new_nil(&_godot_variant);
 }
 
-Variant::Variant(const Dictionary& p_dictionary)
-{
-	godot::api->godot_variant_new_dictionary(&_godot_variant, (godot_dictionary *) &p_dictionary);
+Variant::Variant(const Dictionary &p_dictionary) {
+	godot::api->godot_variant_new_dictionary(&_godot_variant, (godot_dictionary *)&p_dictionary);
 }
 
-Variant::Variant(const Array& p_array)
-{
-	godot::api->godot_variant_new_array(&_godot_variant, (godot_array *) &p_array);
+Variant::Variant(const Array &p_array) {
+	godot::api->godot_variant_new_array(&_godot_variant, (godot_array *)&p_array);
 }
 
-Variant::Variant(const PoolByteArray& p_raw_array)
-{
-	godot::api->godot_variant_new_pool_byte_array(&_godot_variant, (godot_pool_byte_array *) &p_raw_array);
+Variant::Variant(const PoolByteArray &p_raw_array) {
+	godot::api->godot_variant_new_pool_byte_array(&_godot_variant, (godot_pool_byte_array *)&p_raw_array);
 }
 
-Variant::Variant(const PoolIntArray& p_int_array)
-{
-	godot::api->godot_variant_new_pool_int_array(&_godot_variant, (godot_pool_int_array *) &p_int_array);
+Variant::Variant(const PoolIntArray &p_int_array) {
+	godot::api->godot_variant_new_pool_int_array(&_godot_variant, (godot_pool_int_array *)&p_int_array);
 }
 
-Variant::Variant(const PoolRealArray& p_real_array)
-{
-	godot::api->godot_variant_new_pool_real_array(&_godot_variant, (godot_pool_real_array *) &p_real_array);
+Variant::Variant(const PoolRealArray &p_real_array) {
+	godot::api->godot_variant_new_pool_real_array(&_godot_variant, (godot_pool_real_array *)&p_real_array);
 }
 
-Variant::Variant(const PoolStringArray& p_string_array)
-{
-	godot::api->godot_variant_new_pool_string_array(&_godot_variant, (godot_pool_string_array *) &p_string_array);
+Variant::Variant(const PoolStringArray &p_string_array) {
+	godot::api->godot_variant_new_pool_string_array(&_godot_variant, (godot_pool_string_array *)&p_string_array);
 }
 
-Variant::Variant(const PoolVector2Array& p_vector2_array)
-{
-	godot::api->godot_variant_new_pool_vector2_array(&_godot_variant, (godot_pool_vector2_array *) &p_vector2_array);
+Variant::Variant(const PoolVector2Array &p_vector2_array) {
+	godot::api->godot_variant_new_pool_vector2_array(&_godot_variant, (godot_pool_vector2_array *)&p_vector2_array);
 }
 
-Variant::Variant(const PoolVector3Array& p_vector3_array)
-{
-	godot::api->godot_variant_new_pool_vector3_array(&_godot_variant, (godot_pool_vector3_array *) &p_vector3_array);
+Variant::Variant(const PoolVector3Array &p_vector3_array) {
+	godot::api->godot_variant_new_pool_vector3_array(&_godot_variant, (godot_pool_vector3_array *)&p_vector3_array);
 }
 
-Variant::Variant(const PoolColorArray& p_color_array)
-{
-	godot::api->godot_variant_new_pool_color_array(&_godot_variant, (godot_pool_color_array *) &p_color_array);
+Variant::Variant(const PoolColorArray &p_color_array) {
+	godot::api->godot_variant_new_pool_color_array(&_godot_variant, (godot_pool_color_array *)&p_color_array);
 }
 
-
-Variant &Variant::operator =(const Variant& v)
-{
+Variant &Variant::operator=(const Variant &v) {
 	godot::api->godot_variant_new_copy(&_godot_variant, &v._godot_variant);
 	return *this;
 }
 
-
-Variant::operator bool() const
-{
+Variant::operator bool() const {
 	return booleanize();
 }
-Variant::operator signed int() const
-{
+Variant::operator signed int() const {
 	return godot::api->godot_variant_as_int(&_godot_variant);
 }
 Variant::operator unsigned int() const // this is the real one
 {
 	return godot::api->godot_variant_as_uint(&_godot_variant);
 }
-Variant::operator signed short() const
-{
+Variant::operator signed short() const {
 	return godot::api->godot_variant_as_int(&_godot_variant);
 }
-Variant::operator unsigned short() const
-{
+Variant::operator unsigned short() const {
 	return godot::api->godot_variant_as_uint(&_godot_variant);
 }
-Variant::operator signed char() const
-{
+Variant::operator signed char() const {
 	return godot::api->godot_variant_as_int(&_godot_variant);
 }
-Variant::operator unsigned char() const
-{
+Variant::operator unsigned char() const {
 	return godot::api->godot_variant_as_uint(&_godot_variant);
 }
-Variant::operator int64_t() const
-{
+Variant::operator int64_t() const {
 	return godot::api->godot_variant_as_int(&_godot_variant);
 }
-Variant::operator uint64_t() const
-{
+Variant::operator uint64_t() const {
 	return godot::api->godot_variant_as_uint(&_godot_variant);
 }
 
-
-Variant::operator wchar_t() const
-{
+Variant::operator wchar_t() const {
 	return godot::api->godot_variant_as_int(&_godot_variant);
 }
 
-Variant::operator float() const
-{
+Variant::operator float() const {
 	return godot::api->godot_variant_as_real(&_godot_variant);
 }
 
-Variant::operator double() const
-{
+Variant::operator double() const {
 	return godot::api->godot_variant_as_real(&_godot_variant);
 }
-Variant::operator String() const
-{
+Variant::operator String() const {
 	godot_string s = godot::api->godot_variant_as_string(&_godot_variant);
-	return *(String *) &s;
+	return *(String *)&s;
 }
-Variant::operator Vector2() const
-{
+Variant::operator Vector2() const {
 	godot_vector2 s = godot::api->godot_variant_as_vector2(&_godot_variant);
-	return *(Vector2 *) &s;
+	return *(Vector2 *)&s;
 }
-Variant::operator Rect2() const
-{
+Variant::operator Rect2() const {
 	godot_rect2 s = godot::api->godot_variant_as_rect2(&_godot_variant);
-	return *(Rect2 *) &s;
+	return *(Rect2 *)&s;
 }
-Variant::operator Vector3() const
-{
+Variant::operator Vector3() const {
 	godot_vector3 s = godot::api->godot_variant_as_vector3(&_godot_variant);
-	return *(Vector3 *) &s;
+	return *(Vector3 *)&s;
 }
-Variant::operator Plane() const
-{
+Variant::operator Plane() const {
 	godot_plane s = godot::api->godot_variant_as_plane(&_godot_variant);
-	return *(Plane *) &s;
+	return *(Plane *)&s;
 }
-Variant::operator AABB() const
-{
+Variant::operator AABB() const {
 	godot_aabb s = godot::api->godot_variant_as_aabb(&_godot_variant);
-	return *(AABB *) &s;
+	return *(AABB *)&s;
 }
-Variant::operator Quat() const
-{
+Variant::operator Quat() const {
 	godot_quat s = godot::api->godot_variant_as_quat(&_godot_variant);
-	return *(Quat *) &s;
+	return *(Quat *)&s;
 }
-Variant::operator Basis() const
-{
+Variant::operator Basis() const {
 	godot_basis s = godot::api->godot_variant_as_basis(&_godot_variant);
-	return *(Basis *) &s;
+	return *(Basis *)&s;
 }
-Variant::operator Transform() const
-{
+Variant::operator Transform() const {
 	godot_transform s = godot::api->godot_variant_as_transform(&_godot_variant);
-	return *(Transform *) &s;
+	return *(Transform *)&s;
 }
-Variant::operator Transform2D() const
-{
+Variant::operator Transform2D() const {
 	godot_transform2d s = godot::api->godot_variant_as_transform2d(&_godot_variant);
-	return *(Transform2D *) &s;
+	return *(Transform2D *)&s;
 }
 
-Variant::operator Color() const
-{
+Variant::operator Color() const {
 	godot_color s = godot::api->godot_variant_as_color(&_godot_variant);
-	return *(Color *) &s;
+	return *(Color *)&s;
 }
-Variant::operator NodePath() const
-{
+Variant::operator NodePath() const {
 	godot_node_path s = godot::api->godot_variant_as_node_path(&_godot_variant);
-	return *(NodePath *) &s;
+	return *(NodePath *)&s;
 }
-Variant::operator RID() const
-{
+Variant::operator RID() const {
 	godot_rid s = godot::api->godot_variant_as_rid(&_godot_variant);
-	return *(RID *) &s;
+	return *(RID *)&s;
 }
 
-Variant::operator Dictionary() const
-{
+Variant::operator Dictionary() const {
 	godot_dictionary d = godot::api->godot_variant_as_dictionary(&_godot_variant);
-	return *(Dictionary *) &d;
+	return *(Dictionary *)&d;
 }
 
-Variant::operator Array() const
-{
+Variant::operator Array() const {
 	godot_array s = godot::api->godot_variant_as_array(&_godot_variant);
-	return *(Array *) &s;
+	return *(Array *)&s;
 }
 
-Variant::operator PoolByteArray() const
-{
+Variant::operator PoolByteArray() const {
 	godot_pool_byte_array s = godot::api->godot_variant_as_pool_byte_array(&_godot_variant);
-	return *(PoolByteArray *) &s;
+	return *(PoolByteArray *)&s;
 }
-Variant::operator PoolIntArray() const
-{
+Variant::operator PoolIntArray() const {
 	godot_pool_int_array s = godot::api->godot_variant_as_pool_int_array(&_godot_variant);
-	return *(PoolIntArray *) &s;
+	return *(PoolIntArray *)&s;
 }
-Variant::operator PoolRealArray() const
-{
+Variant::operator PoolRealArray() const {
 	godot_pool_real_array s = godot::api->godot_variant_as_pool_real_array(&_godot_variant);
-	return *(PoolRealArray *) &s;
+	return *(PoolRealArray *)&s;
 }
-Variant::operator PoolStringArray() const
-{
+Variant::operator PoolStringArray() const {
 	godot_pool_string_array s = godot::api->godot_variant_as_pool_string_array(&_godot_variant);
-	return *(PoolStringArray *) &s;
+	return *(PoolStringArray *)&s;
 }
-Variant::operator PoolVector2Array() const
-{
+Variant::operator PoolVector2Array() const {
 	godot_pool_vector2_array s = godot::api->godot_variant_as_pool_vector2_array(&_godot_variant);
-	return *(PoolVector2Array *) &s;
+	return *(PoolVector2Array *)&s;
 }
-Variant::operator PoolVector3Array() const
-{
+Variant::operator PoolVector3Array() const {
 	godot_pool_vector3_array s = godot::api->godot_variant_as_pool_vector3_array(&_godot_variant);
-	return *(PoolVector3Array *) &s;
+	return *(PoolVector3Array *)&s;
 }
-Variant::operator PoolColorArray() const
-{
+Variant::operator PoolColorArray() const {
 	godot_pool_color_array s = godot::api->godot_variant_as_pool_color_array(&_godot_variant);
-	return *(PoolColorArray *) &s;
+	return *(PoolColorArray *)&s;
 }
-Variant::operator Object*() const {
-	godot_object *o = godot::api->godot_variant_as_object(&_godot_variant);
-	return (Object *) o;
+Variant::operator godot_object *() const {
+	return godot::api->godot_variant_as_object(&_godot_variant);
 }
 
-Variant::Type Variant::get_type() const
-{
-	return (Type) godot::api->godot_variant_get_type(&_godot_variant);
+Variant::Type Variant::get_type() const {
+	return (Type)godot::api->godot_variant_get_type(&_godot_variant);
 }
 
-
-Variant Variant::call(const String& method, const Variant **args, const int arg_count)
-{
+Variant Variant::call(const String &method, const Variant **args, const int arg_count) {
 	Variant v;
-	*(godot_variant *) &v = godot::api->godot_variant_call(&_godot_variant, (godot_string *) &method, (const godot_variant **)args, arg_count, nullptr);
+	*(godot_variant *)&v = godot::api->godot_variant_call(&_godot_variant, (godot_string *)&method, (const godot_variant **)args, arg_count, nullptr);
 	return v;
 }
 
-bool Variant::has_method(const String& method)
-{
-	return godot::api->godot_variant_has_method(&_godot_variant, (godot_string *) &method);
+bool Variant::has_method(const String &method) {
+	return godot::api->godot_variant_has_method(&_godot_variant, (godot_string *)&method);
 }
 
-bool Variant::operator ==(const Variant& b) const
-{
+bool Variant::operator==(const Variant &b) const {
 	return godot::api->godot_variant_operator_equal(&_godot_variant, &b._godot_variant);
 }
 
-bool Variant::operator !=(const Variant& b) const
-{
+bool Variant::operator!=(const Variant &b) const {
 	return !(*this == b);
 }
 
-bool Variant::operator <(const Variant& b) const
-{
+bool Variant::operator<(const Variant &b) const {
 	return godot::api->godot_variant_operator_less(&_godot_variant, &b._godot_variant);
 }
 
-bool Variant::operator <=(const Variant& b) const
-{
+bool Variant::operator<=(const Variant &b) const {
 	return (*this < b) || (*this == b);
 }
 
-bool Variant::operator >(const Variant& b) const
-{
+bool Variant::operator>(const Variant &b) const {
 	return !(*this <= b);
 }
 
-bool Variant::operator >=(const Variant& b) const
-{
+bool Variant::operator>=(const Variant &b) const {
 	return !(*this < b);
 }
 
-bool Variant::hash_compare(const Variant& b) const
-{
+bool Variant::hash_compare(const Variant &b) const {
 	return godot::api->godot_variant_hash_compare(&_godot_variant, &b._godot_variant);
 }
 
-bool Variant::booleanize() const
-{
+bool Variant::booleanize() const {
 	return godot::api->godot_variant_booleanize(&_godot_variant);
 }
 
-Variant::~Variant()
-{
+Variant::~Variant() {
 	godot::api->godot_variant_destroy(&_godot_variant);
 }
 
-
-
-}
-
+} // namespace godot

src/core/Vector2.cpp

@@ -8,150 +8,123 @@
 
 namespace godot {
 
-Vector2 Vector2::operator+(const Vector2& p_v) const
-{
+Vector2 Vector2::operator+(const Vector2 &p_v) const {
 	return Vector2(x + p_v.x, y + p_v.y);
 }
 
-void Vector2::operator+=(const Vector2& p_v)
-{
+void Vector2::operator+=(const Vector2 &p_v) {
 	x += p_v.x;
 	y += p_v.y;
 }
 
-Vector2 Vector2::operator-(const Vector2& p_v) const
-{
+Vector2 Vector2::operator-(const Vector2 &p_v) const {
 	return Vector2(x - p_v.x, y - p_v.y);
 }
 
-void Vector2::operator-=(const Vector2& p_v)
-{
+void Vector2::operator-=(const Vector2 &p_v) {
 	x -= p_v.x;
 	y -= p_v.y;
 }
 
-Vector2 Vector2::operator*(const Vector2 &p_v1) const
-{
+Vector2 Vector2::operator*(const Vector2 &p_v1) const {
 	return Vector2(x * p_v1.x, y * p_v1.y);
 }
 
-Vector2 Vector2::operator*(const real_t &rvalue) const
-{
+Vector2 Vector2::operator*(const real_t &rvalue) const {
 	return Vector2(x * rvalue, y * rvalue);
 }
 
-void Vector2::operator*=(const real_t &rvalue)
-{
+void Vector2::operator*=(const real_t &rvalue) {
 	x *= rvalue;
 	y *= rvalue;
 }
 
-Vector2 Vector2::operator/(const Vector2 &p_v1) const
-{
+Vector2 Vector2::operator/(const Vector2 &p_v1) const {
 	return Vector2(x / p_v1.x, y / p_v1.y);
 }
 
-Vector2 Vector2::operator/(const real_t &rvalue) const
-{
+Vector2 Vector2::operator/(const real_t &rvalue) const {
 	return Vector2(x / rvalue, y / rvalue);
 }
 
-void Vector2::operator/=(const real_t &rvalue)
-{
+void Vector2::operator/=(const real_t &rvalue) {
 	x /= rvalue;
 	y /= rvalue;
 }
 
-Vector2 Vector2::operator-() const
-{
+Vector2 Vector2::operator-() const {
 	return Vector2(-x, -y);
 }
 
-bool Vector2::operator==(const Vector2& p_vec2) const
-{
+bool Vector2::operator==(const Vector2 &p_vec2) const {
 	return x == p_vec2.x && y == p_vec2.y;
 }
 
-bool Vector2::operator!=(const Vector2& p_vec2) const
-{
+bool Vector2::operator!=(const Vector2 &p_vec2) const {
 	return x != p_vec2.x || y != p_vec2.y;
 }
 
-void Vector2::normalize()
-{
-	real_t l = x*x + y*y;
+void Vector2::normalize() {
+	real_t l = x * x + y * y;
 	if (l != 0) {
-		l = (l);
+		l = sqrt(l);
 		x /= l;
 		y /= l;
 	}
 }
 
-Vector2 Vector2::normalized() const
-{
+Vector2 Vector2::normalized() const {
 	Vector2 v = *this;
 	v.normalize();
 	return v;
 }
 
-real_t Vector2::length() const
-{
-	return sqrt(x*x + y*y);
+real_t Vector2::length() const {
+	return sqrt(x * x + y * y);
 }
-real_t Vector2::length_squared() const
-{
-	return x*x + y*y;
+real_t Vector2::length_squared() const {
+	return x * x + y * y;
 }
 
-real_t Vector2::distance_to(const Vector2& p_vector2) const
-{
+real_t Vector2::distance_to(const Vector2 &p_vector2) const {
 	return sqrt((x - p_vector2.x) * (x - p_vector2.x) + (y - p_vector2.y) * (y - p_vector2.y));
 }
 
-real_t Vector2::distance_squared_to(const Vector2& p_vector2) const
-{
+real_t Vector2::distance_squared_to(const Vector2 &p_vector2) const {
 	return (x - p_vector2.x) * (x - p_vector2.x) + (y - p_vector2.y) * (y - p_vector2.y);
 }
 
-real_t Vector2::angle_to(const Vector2& p_vector2) const
-{
+real_t Vector2::angle_to(const Vector2 &p_vector2) const {
 	return atan2(cross(p_vector2), dot(p_vector2));
 }
 
-real_t Vector2::angle_to_point(const Vector2& p_vector2) const
-{
-	return atan2(y - p_vector2.y, x-p_vector2.x);
+real_t Vector2::angle_to_point(const Vector2 &p_vector2) const {
+	return atan2(y - p_vector2.y, x - p_vector2.x);
 }
 
-real_t Vector2::dot(const Vector2& p_other) const
-{
+real_t Vector2::dot(const Vector2 &p_other) const {
 	return x * p_other.x + y * p_other.y;
 }
 
-real_t Vector2::cross(const Vector2& p_other) const
-{
+real_t Vector2::cross(const Vector2 &p_other) const {
 	return x * p_other.y - y * p_other.x;
 }
 
-Vector2 Vector2::cross(real_t p_other) const
-{
+Vector2 Vector2::cross(real_t p_other) const {
 	return Vector2(p_other * y, -p_other * x);
 }
 
-Vector2 Vector2::project(const Vector2& p_vec) const
-{
+Vector2 Vector2::project(const Vector2 &p_vec) const {
 	Vector2 v1 = p_vec;
 	Vector2 v2 = *this;
 	return v2 * (v1.dot(v2) / v2.dot(v2));
 }
 
-Vector2 Vector2::plane_project(real_t p_d, const Vector2& p_vec) const
-{
-	return  p_vec - *this * ( dot(p_vec) -p_d);
+Vector2 Vector2::plane_project(real_t p_d, const Vector2 &p_vec) const {
+	return p_vec - *this * (dot(p_vec) - p_d);
 }
 
-Vector2 Vector2::clamped(real_t p_len) const
-{
+Vector2 Vector2::clamped(real_t p_len) const {
 	real_t l = length();
 	Vector2 v = *this;
 	if (l > 0 && p_len < l) {
@@ -161,55 +134,48 @@ Vector2 Vector2::clamped(real_t p_len) const
 	return v;
 }
 
-Vector2 Vector2::linear_interpolate(const Vector2& p_a, const Vector2& p_b,real_t p_t)
-{
-	Vector2 res=p_a;
-	res.x+= (p_t * (p_b.x-p_a.x));
-	res.y+= (p_t * (p_b.y-p_a.y));
+Vector2 Vector2::linear_interpolate(const Vector2 &p_a, const Vector2 &p_b, real_t p_t) {
+	Vector2 res = p_a;
+	res.x += (p_t * (p_b.x - p_a.x));
+	res.y += (p_t * (p_b.y - p_a.y));
 	return res;
 }
 
-Vector2 Vector2::linear_interpolate(const Vector2& p_b,real_t p_t) const
-{
-	Vector2 res=*this;
-	res.x+= (p_t * (p_b.x-x));
-	res.y+= (p_t * (p_b.y-y));
+Vector2 Vector2::linear_interpolate(const Vector2 &p_b, real_t p_t) const {
+	Vector2 res = *this;
+	res.x += (p_t * (p_b.x - x));
+	res.y += (p_t * (p_b.y - y));
 	return res;
-
 }
-Vector2 Vector2::cubic_interpolate(const Vector2& p_b,const Vector2& p_pre_a, const Vector2& p_post_b,real_t p_t) const
-{
-	Vector2 p0=p_pre_a;
-	Vector2 p1=*this;
-	Vector2 p2=p_b;
-	Vector2 p3=p_post_b;
+Vector2 Vector2::cubic_interpolate(const Vector2 &p_b, const Vector2 &p_pre_a, const Vector2 &p_post_b, real_t p_t) const {
+	Vector2 p0 = p_pre_a;
+	Vector2 p1 = *this;
+	Vector2 p2 = p_b;
+	Vector2 p3 = p_post_b;
 
 	real_t t = p_t;
 	real_t t2 = t * t;
 	real_t t3 = t2 * t;
 
 	Vector2 out;
-	out = ( ( p1 * 2.0) +
-	( -p0 + p2 ) * t +
-	( p0 * 2.0 - p1 * 5.0 + p2 * 4 - p3 ) * t2 +
-	( -p0 + p1 * 3.0 - p2 * 3.0 + p3 ) * t3 ) * 0.5;
+	out = ((p1 * 2.0) +
+				  (-p0 + p2) * t +
+				  (p0 * 2.0 - p1 * 5.0 + p2 * 4 - p3) * t2 +
+				  (-p0 + p1 * 3.0 - p2 * 3.0 + p3) * t3) *
+		  0.5;
 
 	return out;
 }
 
-
-Vector2 Vector2::slide(const Vector2& p_vec) const
-{
+Vector2 Vector2::slide(const Vector2 &p_vec) const {
 	return p_vec - *this * this->dot(p_vec);
 }
 
-Vector2 Vector2::reflect(const Vector2& p_vec) const
-{
+Vector2 Vector2::reflect(const Vector2 &p_vec) const {
 	return p_vec - *this * this->dot(p_vec) * 2.0;
 }
 
-real_t Vector2::angle() const
-{
+real_t Vector2::angle() const {
 	return atan2(y, x);
 }
 
@@ -221,11 +187,10 @@ void Vector2::set_rotation(real_t p_radians) {
 
 Vector2 Vector2::abs() const {
 
-	return Vector2( fabs(x), fabs(y) );
+	return Vector2(fabs(x), fabs(y));
 }
 
-Vector2 Vector2::rotated(real_t p_by) const
-{
+Vector2 Vector2::rotated(real_t p_by) const {
 	Vector2 v;
 	v.set_rotation(angle() + p_by);
 	v *= length();
@@ -234,26 +199,21 @@ Vector2 Vector2::rotated(real_t p_by) const
 
 Vector2 Vector2::tangent() const {
 
-	return Vector2(y,-x);
+	return Vector2(y, -x);
 }
 
-Vector2 Vector2::floor() const
-{
+Vector2 Vector2::floor() const {
 	return Vector2(::floor(x), ::floor(y));
 }
 
-Vector2 Vector2::snapped(const Vector2& p_by) const
-{
+Vector2 Vector2::snapped(const Vector2 &p_by) const {
 	return Vector2(
-		p_by.x != 0 ? ::floor(x / p_by.x + 0.5) * p_by.x : x,
-		p_by.y != 0 ? ::floor(y / p_by.y + 0.5) * p_by.y : y
-	);
+			p_by.x != 0 ? ::floor(x / p_by.x + 0.5) * p_by.x : x,
+			p_by.y != 0 ? ::floor(y / p_by.y + 0.5) * p_by.y : y);
 }
 
-Vector2::operator String() const
-{
+Vector2::operator String() const {
 	return String::num(x) + ", " + String::num(y);
 }
 
-
-}
+} // namespace godot

src/core/Vector3.cpp

@@ -10,326 +10,293 @@
 
 namespace godot {
 
-
-Vector3::Vector3(real_t x, real_t y, real_t z)
-{
+Vector3::Vector3(real_t x, real_t y, real_t z) {
 	this->x = x;
 	this->y = y;
 	this->z = z;
 }
 
-Vector3::Vector3()
-{
+Vector3::Vector3() {
 	this->x = 0;
 	this->y = 0;
 	this->z = 0;
 }
 
-const real_t& Vector3::operator[](int p_axis) const
-{
+const real_t &Vector3::operator[](int p_axis) const {
 	return coord[p_axis];
 }
 
-real_t& Vector3::operator[](int p_axis)
-{
+real_t &Vector3::operator[](int p_axis) {
 	return coord[p_axis];
 }
 
-Vector3& Vector3::operator+=(const Vector3& p_v)
-{
+Vector3 &Vector3::operator+=(const Vector3 &p_v) {
 	x += p_v.x;
 	y += p_v.y;
 	z += p_v.z;
 	return *this;
 }
 
-Vector3 Vector3::operator+(const Vector3& p_v) const
-{
+Vector3 Vector3::operator+(const Vector3 &p_v) const {
 	Vector3 v = *this;
 	v += p_v;
 	return v;
 }
 
-Vector3& Vector3::operator-=(const Vector3& p_v)
-{
+Vector3 &Vector3::operator-=(const Vector3 &p_v) {
 	x -= p_v.x;
 	y -= p_v.y;
 	z -= p_v.z;
 	return *this;
 }
 
-Vector3 Vector3::operator-(const Vector3& p_v) const
-{
+Vector3 Vector3::operator-(const Vector3 &p_v) const {
 	Vector3 v = *this;
 	v -= p_v;
 	return v;
 }
 
-Vector3& Vector3::operator*=(const Vector3& p_v)
-{
+Vector3 &Vector3::operator*=(const Vector3 &p_v) {
 	x *= p_v.x;
 	y *= p_v.y;
 	z *= p_v.z;
 	return *this;
 }
 
-Vector3 Vector3::operator*(const Vector3& p_v) const
-{
+Vector3 Vector3::operator*(const Vector3 &p_v) const {
 	Vector3 v = *this;
 	v *= p_v;
 	return v;
 }
 
-Vector3& Vector3::operator/=(const Vector3& p_v)
-{
+Vector3 &Vector3::operator/=(const Vector3 &p_v) {
 	x /= p_v.x;
 	y /= p_v.y;
 	z /= p_v.z;
 	return *this;
 }
 
-Vector3 Vector3::operator/(const Vector3& p_v) const
-{
+Vector3 Vector3::operator/(const Vector3 &p_v) const {
 	Vector3 v = *this;
 	v /= p_v;
 	return v;
 }
 
-
-Vector3& Vector3::operator*=(real_t p_scalar)
-{
+Vector3 &Vector3::operator*=(real_t p_scalar) {
 	*this *= Vector3(p_scalar, p_scalar, p_scalar);
 	return *this;
 }
 
-Vector3 Vector3::operator*(real_t p_scalar) const
-{
+Vector3 Vector3::operator*(real_t p_scalar) const {
 	Vector3 v = *this;
 	v *= p_scalar;
 	return v;
 }
 
-Vector3& Vector3::operator/=(real_t p_scalar)
-{
+Vector3 &Vector3::operator/=(real_t p_scalar) {
 	*this /= Vector3(p_scalar, p_scalar, p_scalar);
 	return *this;
 }
 
-Vector3 Vector3::operator/(real_t p_scalar) const
-{
+Vector3 Vector3::operator/(real_t p_scalar) const {
 	Vector3 v = *this;
 	v /= p_scalar;
 	return v;
 }
 
-Vector3 Vector3::operator-() const
-{
+Vector3 Vector3::operator-() const {
 	return Vector3(-x, -y, -z);
 }
 
-bool Vector3::operator==(const Vector3& p_v) const
-{
-	return (x==p_v.x && y==p_v.y && z==p_v.z);
+bool Vector3::operator==(const Vector3 &p_v) const {
+	return (x == p_v.x && y == p_v.y && z == p_v.z);
 }
 
-bool Vector3::operator!=(const Vector3& p_v) const
-{
-	return (x!=p_v.x || y!=p_v.y || z!=p_v.z);
+bool Vector3::operator!=(const Vector3 &p_v) const {
+	return (x != p_v.x || y != p_v.y || z != p_v.z);
 }
 
-bool Vector3::operator<(const Vector3& p_v) const
-{
-	if (x==p_v.x) {
-		if (y==p_v.y)
-			return z<p_v.z;
+bool Vector3::operator<(const Vector3 &p_v) const {
+	if (x == p_v.x) {
+		if (y == p_v.y)
+			return z < p_v.z;
 		else
-			return y<p_v.y;
+			return y < p_v.y;
 	} else {
-		return x<p_v.x;
+		return x < p_v.x;
 	}
 }
 
-bool Vector3::operator<=(const Vector3& p_v) const
-{
-	if (x==p_v.x) {
-		if (y==p_v.y)
-			return z<=p_v.z;
+bool Vector3::operator<=(const Vector3 &p_v) const {
+	if (x == p_v.x) {
+		if (y == p_v.y)
+			return z <= p_v.z;
 		else
-			return y<p_v.y;
+			return y < p_v.y;
 	} else {
-		return x<p_v.x;
+		return x < p_v.x;
 	}
 }
 
-Vector3 Vector3::abs() const
-{
+Vector3 Vector3::abs() const {
 	return Vector3(::fabs(x), ::fabs(y), ::fabs(z));
 }
 
-Vector3 Vector3::ceil() const
-{
+Vector3 Vector3::ceil() const {
 	return Vector3(::ceil(x), ::ceil(y), ::ceil(z));
 }
 
-Vector3 Vector3::cross(const Vector3& b) const
-{
-	Vector3 ret (
-		(y * b.z) - (z * b.y),
-		(z * b.x) - (x * b.z),
-		(x * b.y) - (y * b.x)
-	);
+Vector3 Vector3::cross(const Vector3 &b) const {
+	Vector3 ret(
+			(y * b.z) - (z * b.y),
+			(z * b.x) - (x * b.z),
+			(x * b.y) - (y * b.x));
 
 	return ret;
 }
 
-Vector3 Vector3::linear_interpolate(const Vector3& p_b,real_t p_t) const
-{
+Vector3 Vector3::linear_interpolate(const Vector3 &p_b, real_t p_t) const {
 	return Vector3(
-		x+(p_t * (p_b.x-x)),
-		y+(p_t * (p_b.y-y)),
-		z+(p_t * (p_b.z-z))
-	);
+			x + (p_t * (p_b.x - x)),
+			y + (p_t * (p_b.y - y)),
+			z + (p_t * (p_b.z - z)));
 }
 
-Vector3 Vector3::cubic_interpolate(const Vector3& b, const Vector3& pre_a, const Vector3& post_b, const real_t t) const
-{
-	Vector3 p0=pre_a;
-	Vector3 p1=*this;
-	Vector3 p2=b;
-	Vector3 p3=post_b;
+Vector3 Vector3::cubic_interpolate(const Vector3 &b, const Vector3 &pre_a, const Vector3 &post_b, const real_t t) const {
+	Vector3 p0 = pre_a;
+	Vector3 p1 = *this;
+	Vector3 p2 = b;
+	Vector3 p3 = post_b;
 
 	real_t t2 = t * t;
 	real_t t3 = t2 * t;
 
 	Vector3 out;
-	out = ( ( p1 * 2.0) +
-	( -p0 + p2 ) * t +
-	( p0 * 2.0 - p1 * 5.0 + p2 * 4 - p3 ) * t2 +
-	( -p0 + p1 * 3.0 - p2 * 3.0 + p3 ) * t3 ) * 0.5;
+	out = ((p1 * 2.0) +
+				  (-p0 + p2) * t +
+				  (p0 * 2.0 - p1 * 5.0 + p2 * 4 - p3) * t2 +
+				  (-p0 + p1 * 3.0 - p2 * 3.0 + p3) * t3) *
+		  0.5;
 	return out;
 }
 
-real_t Vector3::length() const
-{
-	real_t x2=x*x;
-	real_t y2=y*y;
-	real_t z2=z*z;
-
-	return ::sqrt(x2+y2+z2);
+Vector3 Vector3::bounce(const Vector3 &p_normal) const {
+	return -reflect(p_normal);
 }
 
-real_t Vector3::length_squared() const
-{
-	real_t x2=x*x;
-	real_t y2=y*y;
-	real_t z2=z*z;
+real_t Vector3::length() const {
+	real_t x2 = x * x;
+	real_t y2 = y * y;
+	real_t z2 = z * z;
 
-	return x2+y2+z2;
+	return ::sqrt(x2 + y2 + z2);
 }
 
-real_t Vector3::distance_squared_to(const Vector3& b) const
-{
-	return (b-*this).length();
+real_t Vector3::length_squared() const {
+	real_t x2 = x * x;
+	real_t y2 = y * y;
+	real_t z2 = z * z;
+
+	return x2 + y2 + z2;
 }
 
-real_t Vector3::distance_to(const Vector3& b) const
-{
-	return (b-*this).length_squared();
+real_t Vector3::distance_squared_to(const Vector3 &b) const {
+	return (b - *this).length_squared();
 }
 
-real_t Vector3::dot(const Vector3& b) const
-{
-	return x*b.x + y*b.y + z*b.z;
+real_t Vector3::distance_to(const Vector3 &b) const {
+	return (b - *this).length();
 }
 
-Vector3 Vector3::floor() const
-{
+real_t Vector3::dot(const Vector3 &b) const {
+	return x * b.x + y * b.y + z * b.z;
+}
+
+real_t Vector3::angle_to(const Vector3 &b) const {
+	return std::atan2(cross(b).length(), dot(b));
+}
+
+Vector3 Vector3::floor() const {
 	return Vector3(::floor(x), ::floor(y), ::floor(z));
 }
 
-Vector3 Vector3::inverse() const
-{
-	return Vector3( 1.0/x, 1.0/y, 1.0/z );
+Vector3 Vector3::inverse() const {
+	return Vector3(1.0 / x, 1.0 / y, 1.0 / z);
 }
 
+bool Vector3::is_normalized() const {
+	return std::abs(length_squared() - 1.0) < 0.00001;
+}
 
+Basis Vector3::outer(const Vector3 &b) const {
+	Vector3 row0(x * b.x, x * b.y, x * b.z);
+	Vector3 row1(y * b.x, y * b.y, y * b.z);
+	Vector3 row2(z * b.x, z * b.y, z * b.z);
+	return Basis(row0, row1, row2);
+}
 
-
-int Vector3::max_axis() const
-{
+int Vector3::max_axis() const {
 	return x < y ? (y < z ? 2 : 1) : (x < z ? 2 : 0);
 }
 
-int Vector3::min_axis() const
-{
+int Vector3::min_axis() const {
 	return x < y ? (x < z ? 0 : 2) : (y < z ? 1 : 2);
 }
 
-void Vector3::normalize()
-{
-	real_t l=length();
-	if (l==0) {
-		x=y=z=0;
+void Vector3::normalize() {
+	real_t l = length();
+	if (l == 0) {
+		x = y = z = 0;
 	} else {
-		x/=l;
-		y/=l;
-		z/=l;
+		x /= l;
+		y /= l;
+		z /= l;
 	}
 }
 
-Vector3 Vector3::normalized() const
-{
+Vector3 Vector3::normalized() const {
 	Vector3 v = *this;
 	v.normalize();
 	return v;
 }
 
-Vector3 Vector3::reflect(const Vector3& by) const
-{
+Vector3 Vector3::reflect(const Vector3 &by) const {
 	return by - *this * this->dot(by) * 2.0;
 }
 
-Vector3 Vector3::rotated(const Vector3& axis, const real_t phi) const
-{
+Vector3 Vector3::rotated(const Vector3 &axis, const real_t phi) const {
 	Vector3 v = *this;
 	v.rotate(axis, phi);
 	return v;
 }
 
-void Vector3::rotate(const Vector3& p_axis,real_t p_phi)
-{
-	*this=Basis(p_axis,p_phi).xform(*this);
+void Vector3::rotate(const Vector3 &p_axis, real_t p_phi) {
+	*this = Basis(p_axis, p_phi).xform(*this);
 }
 
-Vector3 Vector3::slide(const Vector3& by) const
-{
+Vector3 Vector3::slide(const Vector3 &by) const {
 	return by - *this * this->dot(by);
 }
 
 // this is ugly as well, but hey, I'm a simple man
 #define _ugly_stepify(val, step) (step != 0 ? ::floor(val / step + 0.5) * step : val)
 
-void Vector3::snap(real_t p_val)
-{
-	x = _ugly_stepify(x,p_val);
-	y = _ugly_stepify(y,p_val);
-	z = _ugly_stepify(z,p_val);
+void Vector3::snap(real_t p_val) {
+	x = _ugly_stepify(x, p_val);
+	y = _ugly_stepify(y, p_val);
+	z = _ugly_stepify(z, p_val);
 }
 
 #undef _ugly_stepify
 
-Vector3 Vector3::snapped(const float by)
-{
+Vector3 Vector3::snapped(const float by) {
 	Vector3 v = *this;
 	v.snap(by);
 	return v;
 }
 
-Vector3::operator String() const
-{
+Vector3::operator String() const {
 	return String::num(x) + ", " + String::num(y) + ", " + String::num(z);
 }
 
-
-}
-
+} // namespace godot

src/gen/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore