Started rewriting the bindings generation script to be more flexible and support multiple bindings engines

lib

@@ -1 +1 @@
-Subproject commit c2936142a3596799a95909d6abc86cdeb24a4afd
+Subproject commit 508a229e0e8154493d94d7904a9efdbcfb32b3b1

scripts/create_lua_library/BindingsGenerator.py

@@ -0,0 +1,193 @@
+import CppHeaderParser
+import ConfigParser
+import io
+import os
+import re
+from LuaBindingsGenerator import *
+
+class BindingsGenerator(object):
+
+	def __init__(self, engines, configFile):
+		self.config = ConfigParser.RawConfigParser(allow_no_value=True)
+		self.config.read(configFile)
+		self.targetDir = self.config.get('global', 'TargetDirectory')
+		self.ignoreFiles = self.config.get('global', 'IgnoreFiles')
+
+		self.symbolsToStrip = self.config.get('global', 'StripSymbols').replace(" ", "").split(",")
+		self.ignoreClasses = self.config.get('global', 'IgnoreClasses').replace(" ", "").split(",")
+		self.ignoreMethods = self.config.get('global', 'IgnoreMethods').replace(" ", "").split(",")
+
+		self.engines = {LuaBindingsGenerator(self.config)}
+
+	# ----------------------------------------------------
+	# Utility methods
+	# ----------------------------------------------------
+
+	def error(self, msg):
+		print("\033[91mERROR: %s" % (msg))
+		print("\033[0m")
+
+	# ----------------------------------------------------
+	# Interface methods called in bindings engines
+	# ----------------------------------------------------
+
+	def processTargetFile(self, targetFile):
+		for e in self.engines:
+			e.processTargetFile(targetFile)
+
+	def processClass(self, c):
+		for e in self.engines:
+			e.processClass(c)
+
+	def finalize(self):
+		for e in self.engines:
+			e.finalize()
+
+	# ----------------------------------------------------
+	# Clean up doxygen stuff out of comment docs
+	# ----------------------------------------------------
+
+	def cleanDocs(self, docs):
+		return docs.replace("/*", "").replace("*/", "").replace("*", "").replace("\n", "").replace("\r", "").replace("::", ".").replace("\t", "")
+	
+	# ----------------------------------------------------
+	# Clean and reduce types to standard identifiers
+	# ----------------------------------------------------
+	def typeFilter(self, ty):
+		ty = ty.replace("Polycode::", "")
+		ty = ty.replace("std::", "")
+		ty = ty.replace("const", "")
+		ty = ty.replace("inline", "")
+		ty = ty.replace("static", "")
+		ty = ty.replace("virtual", "")
+		ty = ty.replace("&", "")
+		ty = re.sub(r'^.*\sint\s*$', 'int', ty) # eg "unsigned int"
+		ty = re.sub(r'^.*\schar\s*$', 'char', ty) # eg "unsigned int"
+		ty = re.sub(r'^.*\slong\s*$', 'int', ty)
+		ty = re.sub(r'^.*\swchar_t\s*$', 'int', ty)
+		ty = re.sub(r'^.*\sshort\s*$', 'int', ty)
+		ty = re.sub(r'^.*\sfloat\s*$', 'Number', ty)
+		ty = re.sub(r'^.*\sdouble\s*$', 'Number', ty) # eg "long double"
+		ty = ty.replace("unsigned", "int")
+		ty = ty.replace("long", "int")
+		ty = ty.replace("float", "Number")
+		ty = ty.replace("double", "Number")
+		ty = ty.replace(" ", "") # Not very safe!
+		return ty
+
+	# ----------------------------------------------------
+	# Parse and clean properties from a class
+	# ----------------------------------------------------
+	def parseClassProperties(self, c):
+		properties = []
+		for pp in c["properties"]["public"]:
+			classPP = {}
+			classPP["name"] = pp["name"]
+			pp["type"] = pp["type"].replace("Polycode::", "")
+			pp["type"] = pp["type"].replace("std::", "")
+			classPP["type"] = self.typeFilter(pp["type"])
+			if pp["type"].find("POLYIGNORE") != -1:
+				continue
+			if pp["type"].find("static ") != -1:
+				if "defaltValue" in pp: #this is misspelled in parser library
+					classPP["defaultValue"] = pp["defaltValue"]
+				if 'doxygen' in pp:
+					classPP["doc"] = self.cleanDocs(pp['doxygen'])
+				properties.append(classPP)
+			else:
+				if pp["type"].find("vector") == -1 and pp["name"] != "setScale" and pp["name"] != "setPosition" and pp["name"] != "BUFFER_CACHE_PRECISION" and not pp["name"].isdigit():
+					properties.append(classPP)
+		return properties
+
+	# ----------------------------------------------------
+	# Parse and clean methods
+	# ----------------------------------------------------
+	def parseClassMethods(self, c):
+		methods = []
+		parsedMethods = []
+		for pm in c["methods"]["public"]:
+			method = {}
+			method["name"] = pm["name"]
+			method["type"] = self.typeFilter(pm["rtnType"])
+			if pm["name"] in parsedMethods or pm["name"].find("operator") > -1 or pm["rtnType"].find("POLYIGNORE") > -1 or pm["name"] in self.ignoreMethods :
+				continue
+			#ignore destructors
+			if pm["name"] == "~"+c["name"]:
+				continue
+			method["parameters"] = []
+			for param in pm["parameters"]:
+				mParam = {}
+				if not "name" in param:
+					continue
+				if not "type" in param:
+					continue
+				if param["type"] == "0":
+					continue
+				mParam["name"] = param["name"]
+				mParam["type"] = self.typeFilter(param["type"])
+				if "defaltValue" in param:
+					mParam["defaultValue"] = param["defaltValue"]
+				method["parameters"].append(mParam)
+			parsedMethods.append(pm["name"])
+			methods.append(method)
+		return methods
+
+	# ----------------------------------------------------
+	# Parse and clean data from a class
+	# ----------------------------------------------------
+	def parseClassData(self, c, ckey):
+		classData = {}
+		classData["name"] = ckey
+		if len(c["inherits"]) > 0:
+			classData["parent"] = c["inherits"][0]["class"]
+		if 'doxygen' in c:
+			classData["doc"] = self.cleanDocs(c['doxygen'])
+		classData["properties"] = self.parseClassProperties(c)
+		classData["methods"] = self.parseClassMethods(c)
+		return classData
+
+	# ----------------------------------------------------
+	# Parse files and create bindings
+	# ----------------------------------------------------
+	def createBindings(self):
+		print("\nPolycode bindings generator v0.1\n")
+		print("\033[93mGenerating bindings...")
+		print("\033[93mParsing files from \033[92m[%s]" % (self.targetDir))
+		
+		if not os.path.isdir(self.targetDir):
+			self.error("Target directory not valid!")
+			return
+		
+		files = os.listdir(self.targetDir)
+		filteredFiles = []
+		for fileName in files:
+			fileName = "%s/%s" % (self.targetDir, fileName)
+			if os.path.isdir(fileName):
+				continue
+			head, tail = os.path.split(fileName)
+			ignore = self.ignoreFiles.replace(" ", "").split(",")
+			if tail.split(".")[1] == "h" and tail.split(".")[0] not in ignore:
+				filteredFiles.append(fileName)
+				self.processTargetFile(tail)
+
+		for fileName in filteredFiles:
+			try:
+				f = open(fileName)
+				contents = f.read()
+				for s in self.symbolsToStrip:
+					contents = contents.replace(s, "")
+
+				cppHeader = CppHeaderParser.CppHeader(contents, "string")
+				for ckey in cppHeader.classes: 
+					if ckey in self.ignoreClasses:
+						continue
+					print("\033[93mParsing class \033[0m[\033[92m%s\033[0m]" % ckey)
+					c = cppHeader.classes[ckey]
+					classData = self.parseClassData(c, ckey)
+					self.processClass(classData)
+				
+			except CppHeaderParser.CppParseError as e:
+				self.error(e)
+				return
+
+		self.finalize()

scripts/create_lua_library/CMakeLists.txt

@@ -1,22 +0,0 @@
-INCLUDE(FindPythonModule)
-
-FIND_PACKAGE(PythonInterp REQUIRED)
-FIND_PYTHON_MODULE(ply REQUIRED)
-IF(NOT PY_PLY)
-	MESSAGE(SEND_ERROR "The Python PLY (Python Lex-Yacc) module is required to generate Lua bindings.")
-ENDIF(NOT PY_PLY)
-
-ADD_CUSTOM_COMMAND(
-OUTPUT luaGenerateCmd
-COMMAND ${PYTHON_EXECUTABLE} create_lua_library.py ../../../Core/Contents/Include Polycode Polycode.h polycore Polycore ../../Contents/LUA/API ../../Contents/LUA/API/Polycode ../../Contents/LUA/Include ../../Contents/LUA/Source
-COMMAND ${PYTHON_EXECUTABLE} create_lua_library.py ../../../Modules/Contents/2DPhysics/Include/ Physics2D Polycode2DPhysics.h physics2d Physics2D ../../../Modules/Bindings/2DPhysics/API ../../../Modules/Bindings/2DPhysics/API/Physics2D ../../../Modules/Bindings/2DPhysics/Include ../../../Modules/Bindings/2DPhysics/Source
-COMMAND ${PYTHON_EXECUTABLE} create_lua_library.py ../../../Modules/Contents/3DPhysics/Include/ Physics3D Polycode3DPhysics.h physics3d Physics3D ../../../Modules/Bindings/3DPhysics/API ../../../Modules/Bindings/3DPhysics/API/Physics3D ../../../Modules/Bindings/3DPhysics/Include ../../../Modules/Bindings/3DPhysics/Source 
-COMMAND ${PYTHON_EXECUTABLE} create_lua_library.py ../../../Modules/Contents/UI/Include/ UI PolycodeUI.h UI UI ../../../Modules/Bindings/UI/API ../../../Modules/Bindings/UI/API/UI ../../../Modules/Bindings/UI/Include ../../../Modules/Bindings/UI/Source
-WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR}
-)
-
-ADD_CUSTOM_TARGET(PolycodeLuaGenerate 
-	DEPENDS Polycore luaGenerateCmd
-	COMMENT "Generating Lua API"
-	SOURCES create_lua_library.py)
-

scripts/create_lua_library/CppHeaderParser3.py

@@ -1,2281 +0,0 @@
-#!/usr/bin/python
-#
-# Author: Jashua R. Cloutier (contact via https://bitbucket.org/senex)
-# Project: http://senexcanis.com/open-source/cppheaderparser/
-#
-# Copyright (C) 2011, Jashua R. Cloutier
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions
-# are met:
-#
-# * Redistributions of source code must retain the above copyright
-#   notice, this list of conditions and the following disclaimer.
-#
-# * Redistributions in binary form must reproduce the above copyright
-#   notice, this list of conditions and the following disclaimer in
-#   the documentation and/or other materials provided with the
-#   distribution.
-#
-# * Neither the name of Jashua R. Cloutier nor the names of its
-#   contributors may be used to endorse or promote products derived from
-#   this software without specific prior written permission.  Stories,
-#   blog entries etc making reference to this project may mention the
-#   name Jashua R. Cloutier in terms of project originator/creator etc.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
-# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-# POSSIBILITY OF SUCH DAMAGE.
-#
-#
-# The CppHeaderParser.py script is written in Python 2.4 and released to
-# the open source community for continuous improvements under the BSD
-# 2.0 new license, which can be found at:
-#
-#   http://www.opensource.org/licenses/bsd-license.php
-#
-"""Parse C++ header files and generate a data structure
-representing the class
-"""
-
-import ply.lex as lex
-import os
-import sys
-import re
-
-import inspect
-
-def lineno():
-    """Returns the current line number in our program."""
-    return inspect.currentframe().f_back.f_lineno
-
-version = __version__ = "2.3"
-
-tokens = [
-    'NUMBER',
-    'NAME',
-    'OPEN_PAREN',
-    'CLOSE_PAREN',
-    'OPEN_BRACE',
-    'CLOSE_BRACE',
-    'OPEN_SQUARE_BRACKET',
-    'CLOSE_SQUARE_BRACKET',
-    'COLON',
-    'SEMI_COLON',
-    'COMMA',
-    'TAB',
-    'BACKSLASH',
-    'PIPE',
-    'PERCENT',
-    'EXCLAMATION',
-    'CARET',
-    'COMMENT_SINGLELINE',
-    'COMMENT_MULTILINE',
-    'PRECOMP_MACRO',
-    'PRECOMP_MACRO_CONT', 
-    'ASTERISK',
-    'AMPERSTAND',
-    'EQUALS',
-    'MINUS',
-    'PLUS',  
-    'DIVIDE', 
-    'CHAR_LITERAL', 
-    'STRING_LITERAL',
-    'NEW_LINE',
-    'SQUOTE',
-]
-
-t_ignore = " \r.?@\f"
-t_NUMBER = r'[0-9][0-9XxA-Fa-f]*'
-t_NAME = r'[<>A-Za-z_~][A-Za-z0-9_]*'
-t_OPEN_PAREN = r'\('
-t_CLOSE_PAREN = r'\)'
-t_OPEN_BRACE = r'{'
-t_CLOSE_BRACE = r'}'
-t_OPEN_SQUARE_BRACKET = r'\['
-t_CLOSE_SQUARE_BRACKET = r'\]'
-t_SEMI_COLON = r';'
-t_COLON = r':'
-t_COMMA = r','
-t_TAB = r'\t'
-t_BACKSLASH = r'\\'
-t_PIPE = r'\|'
-t_PERCENT = r'%'
-t_CARET = r'\^'
-t_EXCLAMATION = r'!'
-t_PRECOMP_MACRO = r'\#.*'
-t_PRECOMP_MACRO_CONT = r'.*\\\n'
-def t_COMMENT_SINGLELINE(t):
-    r'\/\/.*\n'
-    global doxygenCommentCache
-    if t.value.startswith("///") or t.value.startswith("//!"):
-        if doxygenCommentCache:
-            doxygenCommentCache += "\n"
-        if t.value.endswith("\n"):
-            doxygenCommentCache += t.value[:-1]
-        else:
-            doxygenCommentCache += t.value
-    t.lexer.lineno += len([a for a in t.value if a=="\n"])
-t_ASTERISK = r'\*'
-t_MINUS = r'\-'
-t_PLUS = r'\+'
-t_DIVIDE = r'/[^/]'
-t_AMPERSTAND = r'&'
-t_EQUALS = r'='
-t_CHAR_LITERAL = "'.'"
-t_SQUOTE = "'"
-#found at http://wordaligned.org/articles/string-literals-and-regular-expressions
-#TODO: This does not work with the string "bla \" bla"
-t_STRING_LITERAL = r'"([^"\\]|\\.)*"'
-#Found at http://ostermiller.org/findcomment.html
-def t_COMMENT_MULTILINE(t):
-    r'/\*([^*]|[\r\n]|(\*+([^*/]|[\r\n])))*\*+/'
-    global doxygenCommentCache
-    if t.value.startswith("/**") or t.value.startswith("/*!"):
-        #not sure why, but get double new lines
-        v = t.value.replace("\n\n", "\n")
-        #strip prefixing whitespace
-        v = re.sub("\n[\s]+\*", "\n*", v)
-        doxygenCommentCache += v
-    t.lexer.lineno += len([a for a in t.value if a=="\n"])
-def t_NEWLINE(t):
-    r'\n+'
-    t.lexer.lineno += len(t.value)
-
-def t_error(v):
-    print(( "Lex error: ", v ))
-
-lex.lex()
-# Controls error_print
-print_errors = 1
-# Controls warning_print
-print_warnings = 1
-# Controls debug_print
-debug = 0
-# Controls trace_print
-debug_trace = 0
-
-def error_print(arg):
-    if print_errors: print(("[%4d] %s"%(inspect.currentframe().f_back.f_lineno, arg)))
-
-def warning_print(arg):
-    if print_warnings: print(("[%4d] %s"%(inspect.currentframe().f_back.f_lineno, arg)))
-
-def debug_print(arg):
-    global debug
-    if debug: print(("[%4d] %s"%(inspect.currentframe().f_back.f_lineno, arg)))
-
-def trace_print(*arg):
-    global debug_trace
-    if debug_trace:
-        sys.stdout.write("[%s] "%(inspect.currentframe().f_back.f_lineno))
-        for a in arg: sys.stdout.write("%s "%a)
-        sys.stdout.write("\n")
-
-supportedAccessSpecifier = [
-    'public',
-    'protected', 
-    'private'
-]
-
-#Symbols to ignore, usually special macros
-ignoreSymbols = [
-    'Q_OBJECT',
-]
-
-doxygenCommentCache = ""
-
-#Track what was added in what order and at what depth
-parseHistory = []
-
-def is_namespace(nameStack):
-    """Determines if a namespace is being specified"""
-    if len(nameStack) == 0:
-        return False
-    if nameStack[0] == "namespace":
-        return True
-    return False
-
-def is_enum_namestack(nameStack):
-    """Determines if a namestack is an enum namestack"""
-    if len(nameStack) == 0:
-        return False
-    if nameStack[0] == "enum":
-        return True
-    if len(nameStack) > 1 and nameStack[0] == "typedef" and nameStack[1] == "enum":
-        return True
-    return False
-
-def is_fundamental(s):
-    for a in s.split():
-        if a not in ["size_t", "struct", "union", "unsigned", "signed", "bool", "char", "short", "int", "float", "double", "long", "void", "*"]: return False
-    return True
-
-def is_function_pointer_stack(stack):
-    """Count how many non-nested paranthesis are in the stack.  Useful for determining if a stack is a function pointer"""
-    paren_depth = 0
-    paren_count = 0
-    star_after_first_paren = False
-    last_e = None
-    for e in stack:
-        if e == "(":
-            paren_depth += 1
-        elif e == ")" and paren_depth > 0:
-            paren_depth -= 1
-            if paren_depth == 0:
-                paren_count += 1
-        elif e == "*" and last_e == "(" and paren_count == 0 and paren_depth == 1:
-            star_after_first_paren = True
-        last_e = e
-        
-    if star_after_first_paren and paren_count == 2:
-        return True
-    else:
-        return False
-
-def is_method_namestack(stack):
-    r = False
-    if '(' not in stack: r = False
-    elif stack[0] == 'typedef': r = False    # TODO deal with typedef function prototypes
-    #elif '=' in stack and stack.index('=') < stack.index('(') and stack[stack.index('=')-1] != 'operator': r = False    #disabled July6th - allow all operators
-    elif 'operator' in stack: r = True    # allow all operators
-    elif '{' in stack and stack.index('{') < stack.index('('): r = False    # struct that looks like a method/class
-    elif '(' in stack and ')' in stack:
-        if '{' in stack and '}' in stack: r = True
-        elif stack[-1] == ';':
-            if is_function_pointer_stack(stack):
-                r = False
-            else:
-                r = True
-        elif '{' in stack: r = True    # ideally we catch both braces... TODO
-    else: r = False
-    #Test for case of property set to something with parens such as "static const int CONST_A = (1 << 7) - 1;"
-    if r and "(" in stack and "=" in stack and 'operator' not in stack:
-        if stack.index("=") < stack.index("("): r = False
-    return r
-
-def is_property_namestack(nameStack):
-    r = False
-    if '(' not in nameStack and ')' not in nameStack: r = True
-    elif "(" in nameStack and "=" in nameStack and nameStack.index("=") < nameStack.index("("): r = True
-    #See if we are a function pointer
-    if not r and is_function_pointer_stack(nameStack): r = True
-    return r
-
-def detect_lineno(s):
-    """Detect the line number for a given token string"""
-    try:
-        rtn = s.lineno()
-        if rtn != -1:
-            return rtn
-    except: pass
-    global curLine
-    return curLine 
-
-class TagStr(str):
-    """Wrapper for a string that allows us to store the line number associated with it"""
-    lineno_reg = {}
-    def __new__(cls,*args,**kw):
-        new_obj =  str.__new__(cls,*args)
-        if "lineno" in kw:
-            TagStr.lineno_reg[id(new_obj)] = kw["lineno"]
-        return new_obj
-    
-    def __del__(self):
-        try:
-            del TagStr.lineno_reg[id(self)]
-        except: pass
-    
-    def lineno(self):
-        return TagStr.lineno_reg.get(id(self), -1)
-
-class CppParseError(Exception): pass
-    
-class CppClass(dict):
-    """Takes a name stack and turns it into a class
-    
-    Contains the following Keys:
-    self['name'] - Name of the class
-    self['doxygen'] - Doxygen comments associated with the class if they exist
-    self['inherits'] - List of Classes that this one inherits where the values
-        are of the form {"access": Anything in supportedAccessSpecifier
-                                  "class": Name of the class
-    self['methods'] - Dictionary where keys are from supportedAccessSpecifier
-        and values are a lists of CppMethod's
-    self['properties'] - Dictionary where keys are from supportedAccessSpecifier
-        and values are lists of CppVariable's 
-    self['enums'] - Dictionary where keys are from supportedAccessSpecifier and
-        values are lists of CppEnum's
-    self['structs'] - Dictionary where keys are from supportedAccessSpecifier and
-        values are lists of nested Struct's
-    
-    An example of how this could look is as follows:
-    #self =
-    {
-        'name': ""
-        'inherits':[]
-        'methods':
-        {
-            'public':[],
-            'protected':[], 
-            'private':[]
-        }, 
-        'properties':
-        {
-            'public':[],
-            'protected':[], 
-            'private':[]
-        },
-        'enums':
-        {
-            'public':[],
-            'protected':[], 
-            'private':[]
-        }
-    }
-    """
-
-    def get_all_methods(self):
-        r = []
-        for typ in supportedAccessSpecifier: r += self['methods'][typ]
-        return r
-
-    def get_all_method_names( self ):
-        r = []
-        for typ in supportedAccessSpecifier: r += self.get_method_names(typ)        # returns list
-        return r
-
-    def get_all_pure_virtual_methods( self ):
-        r = {}
-        for typ in supportedAccessSpecifier: r.update(self.get_pure_virtual_methods(typ))        # returns dict
-        return r
-
-
-    def get_method_names( self, type='public' ): return [ meth['name'] for meth in self['methods'][ type ] ]
-
-    def get_pure_virtual_methods( self, type='public' ):
-        r = {}
-        for meth in self['methods'][ type ]:
-            if meth['pure_virtual']: r[ meth['name'] ] = meth
-        return r
-
-    def __init__(self, nameStack):
-        self['nested_classes'] = []
-        self['parent'] = None
-        self['abstract'] = False
-        self._public_enums = {}
-        self._public_structs = {}
-        self._public_typedefs = {}
-        self._public_forward_declares = []
-        self['namespace'] = ""
-
-        debug_print( "Class:   %s"%nameStack )
-        if (len(nameStack) < 2):
-            nameStack.insert(1, "")#anonymous struct
-        global doxygenCommentCache
-        if len(doxygenCommentCache):
-            self["doxygen"] = doxygenCommentCache
-            doxygenCommentCache = ""
-        self["name"] = nameStack[1]
-        self["line_number"] = detect_lineno(nameStack[0])
-        
-        #Handle template classes
-        if len(nameStack) > 3 and nameStack[2].startswith("<"):
-            open_template_count = 0
-            param_separator = 0
-            found_first = False
-            i = 0
-            for elm in nameStack:
-                if '<' in elm :
-                    open_template_count += 1
-                    found_first = True
-                elif '>' in elm:
-                    open_template_count -= 1
-                if found_first and open_template_count == 0:
-                    self["name"] = "".join(nameStack[1:i + 1])
-                    break;
-                i += 1
-        elif ":" in nameStack:
-            self['name'] = nameStack[ nameStack.index(':') - 1 ]
-
-        inheritList = []
-
-        if nameStack.count(':') == 1:
-            nameStack = nameStack[nameStack.index(":") + 1:]
-            while len(nameStack):
-                tmpStack = []
-                tmpInheritClass = {"access":"private", "virtual": False}
-                if "," in nameStack:
-                    tmpStack = nameStack[:nameStack.index(",")]
-                    nameStack = nameStack[nameStack.index(",") + 1:]
-                else:
-                    tmpStack = nameStack
-                    nameStack = []
-                
-                # Convert template classes to one name in the last index
-                for i in range(0, len(tmpStack)):
-                    if '<' in tmpStack[i]:
-                        tmpStack2 = tmpStack[:i-1]
-                        tmpStack2.append("".join(tmpStack[i-1:]))
-                        tmpStack = tmpStack2
-                        break
-                if len(tmpStack) == 0:
-                    break;
-                elif len(tmpStack) == 1:
-                    tmpInheritClass["class"] = tmpStack[0]
-                elif len(tmpStack) == 2:
-                    tmpInheritClass["access"] = tmpStack[0]
-                    tmpInheritClass["class"] = tmpStack[1]
-                elif len(tmpStack) == 3 and "virtual" in tmpStack:
-                    tmpInheritClass["access"] = tmpStack[1] if tmpStack[1] != "virtual" else tmpStack[0]
-                    tmpInheritClass["class"] = tmpStack[2]
-                    tmpInheritClass["virtual"] = True
-                else:
-                    warning_print( "Warning: can not parse inheriting class %s"%(" ".join(tmpStack)))
-                    if '>' in tmpStack: pass    # allow skip templates for now
-                    else: raise NotImplemented
-
-                if 'class' in tmpInheritClass: inheritList.append(tmpInheritClass)
-
-        elif nameStack.count(':') == 2: self['parent'] = self['name']; self['name'] = nameStack[-1]
-
-        elif nameStack.count(':') > 2 and nameStack[0] in ("class", "struct"):
-            tmpStack = nameStack[nameStack.index(":") + 1:]
-            
-            superTmpStack = [[]]
-            for tok in tmpStack:
-                if tok == ',':
-                    superTmpStack.append([])
-                else:
-                    superTmpStack[-1].append(tok)
-            
-            for tmpStack in superTmpStack:
-                tmpInheritClass = {"access":"private"}
-                
-                if len(tmpStack) and tmpStack[0] in supportedAccessSpecifier:
-                    tmpInheritClass["access"] = tmpStack[0]
-                    tmpStack = tmpStack[1:]
-                
-                inheritNSStack = []
-                while len(tmpStack) > 3:
-                    if tmpStack[0] == ':': break;
-                    if tmpStack[1] != ':': break;
-                    if tmpStack[2] != ':': break;
-                    inheritNSStack.append(tmpStack[0])
-                    tmpStack = tmpStack[3:]
-                if len(tmpStack) == 1 and tmpStack[0] != ':':
-                     inheritNSStack.append(tmpStack[0])
-                tmpInheritClass["class"] = "::".join(inheritNSStack)
-                inheritList.append(tmpInheritClass)
-
-        self['inherits'] = inheritList
-
-        methodAccessSpecificList = {}
-        propertyAccessSpecificList = {}
-        enumAccessSpecificList = {}
-        structAccessSpecificList = {}
-        typedefAccessSpecificList = {}
-        forwardAccessSpecificList = {}
-        
-        for accessSpecifier in supportedAccessSpecifier:
-            methodAccessSpecificList[accessSpecifier] = []
-            propertyAccessSpecificList[accessSpecifier] = []
-            enumAccessSpecificList[accessSpecifier] = []
-            structAccessSpecificList[accessSpecifier] = []
-            typedefAccessSpecificList[accessSpecifier] = []
-            forwardAccessSpecificList[accessSpecifier] = []
-
-        self['methods'] = methodAccessSpecificList
-        self['properties'] = propertyAccessSpecificList
-        self['enums'] = enumAccessSpecificList
-        self['structs'] = structAccessSpecificList
-        self['typedefs'] = typedefAccessSpecificList
-        self['forward_declares'] = forwardAccessSpecificList
-
- 
-    def show(self):
-        """Convert class to a string"""
-        namespace_prefix = ""
-        if self["namespace"]: namespace_prefix = self["namespace"] + "::"
-        rtn = "%s %s"%(self["declaration_method"], namespace_prefix + self["name"])
-        if self['abstract']: rtn += '    (abstract)\n'
-        else: rtn += '\n'
-
-        if 'doxygen' in list(self.keys()): rtn += self["doxygen"] + '\n'
-        if 'parent' in list(self.keys()) and self['parent']: rtn += 'parent class: ' + self['parent'] + '\n'
-
-        if "inherits" in list(self.keys()):
-            rtn += "  Inherits: "
-            for inheritClass in self["inherits"]:
-                if inheritClass["virtual"]: rtn += "virtual "
-                rtn += "%s %s, "%(inheritClass["access"], inheritClass["class"])
-            rtn += "\n"
-        rtn += "  {\n"
-        for accessSpecifier in supportedAccessSpecifier:
-            rtn += "    %s\n"%(accessSpecifier)
-            #Enums
-            if (len(self["enums"][accessSpecifier])):
-                rtn += "        <Enums>\n"
-            for enum in self["enums"][accessSpecifier]:
-                rtn += "            %s\n"%(repr(enum))
-            #Properties
-            if (len(self["properties"][accessSpecifier])):
-                rtn += "        <Properties>\n"
-            for property in self["properties"][accessSpecifier]:
-                rtn += "            %s\n"%(repr(property))
-            #Methods
-            if (len(self["methods"][accessSpecifier])):
-                rtn += "        <Methods>\n"
-            for method in self["methods"][accessSpecifier]:
-                rtn += "\t\t" + method.show() + '\n'
-        rtn += "  }\n"
-        print(rtn)
-    
-    def __repr__(self):
-        """Convert class to a string"""
-        namespace_prefix = ""
-        if self["namespace"]: namespace_prefix = self["namespace"] + "::"
-        rtn = "%s %s"%(self["declaration_method"], namespace_prefix + self["name"])
-        if self['abstract']: rtn += '    (abstract)\n'
-        else: rtn += '\n'
-
-        if 'doxygen' in list(self.keys()): rtn += self["doxygen"] + '\n'
-        if 'parent' in list(self.keys()) and self['parent']: rtn += 'parent class: ' + self['parent'] + '\n'
-
-        if "inherits" in list(self.keys()) and len(self["inherits"]):
-            rtn += "Inherits: "
-            for inheritClass in self["inherits"]:
-                if inheritClass.get("virtual", False): rtn += "virtual "
-                rtn += "%s %s, "%(inheritClass["access"], inheritClass["class"])
-            rtn += "\n"
-        rtn += "{\n"
-        for accessSpecifier in supportedAccessSpecifier:
-            rtn += "%s\n"%(accessSpecifier)
-            #Enums
-            if (len(self["enums"][accessSpecifier])):
-                rtn += "    // Enums\n"
-            for enum in self["enums"][accessSpecifier]:
-                rtn += "    %s\n"%(repr(enum))
-            #Properties
-            if (len(self["properties"][accessSpecifier])):
-                rtn += "    // Properties\n"
-            for property in self["properties"][accessSpecifier]:
-                rtn += "    %s\n"%(repr(property))
-            #Methods
-            if (len(self["methods"][accessSpecifier])):
-                rtn += "    // Methods\n"
-            for method in self["methods"][accessSpecifier]:
-                rtn += "   %s\n"%(repr(method))
-        rtn += "}\n"
-        return rtn
-
-
-class CppUnion( CppClass ):
-    """Takes a name stack and turns it into a union
-    
-    Contains the following Keys:
-    self['name'] - Name of the union
-    self['doxygen'] - Doxygen comments associated with the union if they exist
-    self['members'] - List of members the union has 
-    
-    An example of how this could look is as follows:
-    #self =
-    {
-        'name': ""
-        'members': []
-    }
-    """
-    
-    def __init__(self, nameStack):
-        CppClass.__init__(self, nameStack)
-        self["name"] = "union " + self["name"]
-        self["members"] = self["properties"]["public"]
-    
-    def transform_to_union_keys(self):
-        print("union keys: %s"%list(self.keys()))
-        for key in ['inherits', 'parent', 'abstract', 'namespace', 'typedefs', 'methods']:
-            del self[key] 
-        
-    def show(self):
-        """Convert class to a string"""
-        print(self)
-    
-    
-    def __repr__(self):
-        """Convert class to a string"""
-        namespace_prefix = ""
-        if self["namespace"]: namespace_prefix = self["namespace"] + "::"
-        rtn = "%s %s"%(self["declaration_method"], namespace_prefix + self["name"])
-        if self['abstract']: rtn += '    (abstract)\n'
-        else: rtn += '\n'
-
-        if 'doxygen' in list(self.keys()): rtn += self["doxygen"] + '\n'
-        if 'parent' in list(self.keys()) and self['parent']: rtn += 'parent class: ' + self['parent'] + '\n'
-
-        rtn += "{\n"
-        for member in self["members"]:
-            rtn += "    %s\n"%(repr(member))
-        rtn += "}\n"
-        return rtn
-
-       
-
-class _CppMethod( dict ):
-    def _params_helper1( self, stack ):
-        # deal with "throw" keyword
-        if 'throw' in stack: stack = stack[ : stack.index('throw') ]
-
-        ## remove GCC keyword __attribute__(...) and preserve returns ##
-        cleaned = []
-        hit = False; hitOpen = 0; hitClose = 0
-        for a in stack:
-            if a == '__attribute__': hit = True
-            if hit:
-                if a == '(': hitOpen += 1
-                elif a == ')': hitClose += 1
-                if a==')' and hitOpen == hitClose:
-                    hit = False
-            else:
-                cleaned.append( a )
-        stack = cleaned
-
-        # also deal with attribute((const)) function prefix #
-        # TODO this needs to be better #
-        if len(stack) > 5:
-            a = ''.join(stack)
-            if a.startswith('((__const__))'): stack = stack[ 5 : ]
-            elif a.startswith('__attribute__((__const__))'): stack = stack[ 6 : ]
-
-        stack = stack[stack.index('(') + 1: ]
-        if not stack: return []
-        if len(stack)>=3 and stack[0]==')' and stack[1]==':':    # is this always a constructor?
-            self['constructor'] = True
-            return []
-
-        stack.reverse(); _end_ = stack.index(')'); stack.reverse()
-        stack = stack[ : len(stack)-(_end_+1) ]
-        if '(' not in stack: return stack    # safe to return, no defaults that init a class
-
-        # transforms ['someclass', '(', '0', '0', '0', ')'] into "someclass(0,0,0)'"
-        r = []; hit=False
-        for a in stack:
-            if a == '(': hit=True
-            elif a == ')': hit=False
-            if hit or a == ')': r[-1] = r[-1] + a
-            else: r.append( a )
-        return r
-
-    def _params_helper2( self, params ):
-        for p in params:
-            p['method'] = self        # save reference in variable to parent method
-            if '::' in p['type']:
-                ns = p['type'].split('::')[0]
-                if ns not in Resolver.NAMESPACES and ns in Resolver.CLASSES:
-                    p['type'] = self['namespace'] + p['type']
-            else: p['namespace'] = self[ 'namespace' ]
-
-class CppMethod( _CppMethod ):
-    """Takes a name stack and turns it into a method
-    
-    Contains the following Keys:
-    self['rtnType'] - Return type of the method (ex. "int")
-    self['name'] - Name of the method (ex. "getSize")
-    self['doxygen'] - Doxygen comments associated with the method if they exist
-    self['parameters'] - List of CppVariables
-    """
-    def show(self):
-        r = ['method name: %s (%s)' %(self['name'],self['debug']) ]
-        if self['returns']: r.append( 'returns: %s'%self['returns'] )
-        if self['parameters']: r.append( 'number arguments: %s' %len(self['parameters']))
-        if self['pure_virtual']: r.append( 'pure virtual: %s'%self['pure_virtual'] )
-        if self['constructor']: r.append( 'constructor' )
-        if self['destructor']: r.append( 'destructor' )
-        return '\n\t\t  '.join( r )
-
-    def __init__(self, nameStack, curClass, methinfo):
-        debug_print( "Method:   %s"%nameStack )
-        global doxygenCommentCache
-        if len(doxygenCommentCache):
-            self["doxygen"] = doxygenCommentCache
-            doxygenCommentCache = ""
-        if "operator" in nameStack:
-            self["rtnType"] = " ".join(nameStack[:nameStack.index('operator')])
-            self["name"] = "".join(nameStack[nameStack.index('operator'):nameStack.index('(')])
-        else:
-            self["rtnType"] = " ".join(nameStack[:nameStack.index('(') - 1])
-            self["name"] = " ".join(nameStack[nameStack.index('(') - 1:nameStack.index('(')])
-        if self["rtnType"].startswith("virtual"):
-           self["rtnType"] = self["rtnType"][len("virtual"):].strip()
-        if len(self["rtnType"]) == 0 or self["name"] == curClass:
-            self["rtnType"] = "void"
-        
-        self["rtnType"] = self["rtnType"].replace(' : : ', '::' )
-        self["rtnType"] = self["rtnType"].replace(" <","<")
-        self["rtnType"] = self["rtnType"].replace(" >",">").replace(">>", "> >").replace(">>", "> >")
-        self["rtnType"] = self["rtnType"].replace(" ,",",")
-        
-        self["const"] = False
-        for i in reversed(nameStack):
-            if i == "const":
-                self["const"] = True
-                break
-            elif i == ")":
-                break        
-
-        self.update( methinfo )
-        self["line_number"] = detect_lineno(nameStack[0])
-
-        #Filter out initializer lists used in constructors
-        try:
-            paren_depth_counter = 0
-            for i in range(0, len(nameStack)):
-                elm = nameStack[i]
-                if elm == "(":
-                    paren_depth_counter += 1
-                if elm == ")":
-                    paren_depth_counter -=1
-                    if paren_depth_counter == 0 and nameStack[i+1] == ':':
-                        debug_print("Stripping out initializer list")
-                        nameStack = nameStack[:i+1]
-                        break
-        except: pass
-        
-        paramsStack = self._params_helper1( nameStack )
-        
-
-        params = []
-        #See if there is a doxygen comment for the variable
-        doxyVarDesc = {}
-        
-        if "doxygen" in self:
-            doxyLines = self["doxygen"].split("\n")
-            lastParamDesc = ""
-            for doxyLine in doxyLines:
-                if " @param " in doxyLine or " \param " in doxyLine:
-                    try:
-                        #Strip out the param
-                        doxyLine = doxyLine[doxyLine.find("param ") + 6:]
-                        (var, desc) = doxyLine.split(" ", 1)
-                        doxyVarDesc[var] = desc.strip()
-                        lastParamDesc = var
-                    except: pass
-                elif " @return " in doxyLine or " \return " in doxyLine:
-                    lastParamDesc = ""
-                    # not handled for now
-                elif lastParamDesc:
-                    try:
-                        doxyLine = doxyLine.strip()
-                        if " " not in doxyLine:
-                            lastParamDesc = ""
-                            continue
-                        doxyLine = doxyLine[doxyLine.find(" ") + 1:]
-                        doxyVarDesc[lastParamDesc] += " " + doxyLine
-                    except: pass
-        
-        #Create the variable now
-        while (len(paramsStack)):
-            # Find commas that are not nexted in <>'s like template types
-            open_template_count = 0
-            param_separator = 0
-            i = 0
-            for elm in paramsStack:
-                if '<' in elm :
-                    open_template_count += 1
-                elif '>' in elm:
-                    open_template_count -= 1
-                elif elm == ',' and open_template_count == 0:
-                    param_separator = i
-                    break
-                i += 1
-            
-            if param_separator:
-                param = CppVariable(paramsStack[0:param_separator],  doxyVarDesc=doxyVarDesc)
-                if len(list(param.keys())): params.append(param)
-                paramsStack = paramsStack[param_separator + 1:]
-            else:
-                param = CppVariable(paramsStack,  doxyVarDesc=doxyVarDesc)
-                if len(list(param.keys())): params.append(param)
-                break
-
-
-        self["parameters"] = params
-        self._params_helper2( params )    # mods params inplace
-
-    def __repr__(self):
-        filter_keys = ("parent", "defined", "operator", "returns_reference")
-        cpy = dict((k,v) for (k,v) in list(self.items()) if k not in filter_keys)
-        return "%s"%cpy
-
-
-class _CppVariable(dict):
-    def _name_stack_helper( self, stack ):
-        stack = list(stack)
-        if '=' not in stack:        # TODO refactor me
-            # check for array[n] and deal with funny array syntax: "int myvar:99"
-            array = []
-            while stack and stack[-1].isdigit(): array.append( stack.pop() )
-            if array: array.reverse(); self['array'] = int(''.join(array))
-            if stack and stack[-1].endswith(':'): stack[-1] = stack[-1][:-1]
-
-        while stack and not stack[-1]: stack.pop()            # can be empty
-        return stack
-
-    def init(self):
-        #assert self['name']    # allow unnamed variables, methods like this: "void func(void);"
-        a = []
-        self['aliases'] = []; self['parent'] = None; self['typedef'] = None
-        for key in 'constant reference pointer static typedefs class fundamental unresolved'.split():
-            self[ key ] = 0
-        for b in self['type'].split():
-            if b == '__const__': b = 'const'
-            a.append( b )
-        self['type'] = ' '.join( a )
-
-
-class CppVariable( _CppVariable ):
-    """Takes a name stack and turns it into a method
-    
-    Contains the following Keys:
-    self['type'] - Type for the variable (ex. "const string &")
-    self['name'] - Name of the variable (ex. "numItems")
-    self['namespace'] - Namespace containing the enum
-    self['desc'] - Description of the variable if part of a method (optional)
-    self['doxygen'] - Doxygen comments associated with the method if they exist
-    self['defaltValue'] - Default value of the variable, this key will only
-        exist if there is a default value
-    """
-    Vars = []
-    def __init__(self, nameStack,  **kwargs):
-        _stack_ = nameStack
-        if "[" in nameStack: #strip off array informatin
-            arrayStack = nameStack[nameStack.index("["):]
-            if len(arrayStack) == 3:
-                self["array_size"] = arrayStack[1] 
-            nameStack = nameStack[:nameStack.index("[")]
-            self["array"] = 1
-        else:
-            self["array"] = 0
-        nameStack = self._name_stack_helper( nameStack )
-        global doxygenCommentCache
-        if len(doxygenCommentCache):
-            self["doxygen"] = doxygenCommentCache
-            doxygenCommentCache = ""
-
-        debug_print( "Variable: %s"%nameStack )
-
-        self["line_number"] = detect_lineno(nameStack[0])
-        self["function_pointer"] = 0
-
-        if (len(nameStack) < 2):    # +++
-            if len(nameStack) == 1: self['type'] = nameStack[0]; self['name'] = ''
-            else: error_print(_stack_); assert 0
-
-        elif is_function_pointer_stack(nameStack): #function pointer
-            self["type"] = " ".join(nameStack[:nameStack.index("(") + 2] + nameStack[nameStack.index(")")  :])
-            self["name"] = " ".join(nameStack[nameStack.index("(") + 2 : nameStack.index(")")])
-            self["function_pointer"] = 1
-
-        elif ("=" in nameStack):
-            self["type"] = " ".join(nameStack[:nameStack.index("=") - 1])
-            self["name"] = nameStack[nameStack.index("=") - 1]
-            self["defaltValue"] = " ".join(nameStack[nameStack.index("=") + 1:])    # deprecate camelCase in dicts
-            self['default'] = " ".join(nameStack[nameStack.index("=") + 1:])
-
-        elif is_fundamental(nameStack[-1]) or nameStack[-1] in ['>', '<' , ':', '.']:
-            #Un named parameter
-            self["type"] = " ".join(nameStack)
-            self["name"] = ""
-
-        else:    # common case
-            self["type"] = " ".join(nameStack[:-1])
-            self["name"] = nameStack[-1]
-
-        self["type"] = self["type"].replace(" :",":")
-        self["type"] = self["type"].replace(": ",":")
-        self["type"] = self["type"].replace(" <","<")
-        self["type"] = self["type"].replace(" >",">").replace(">>", "> >").replace(">>", "> >")
-        self["type"] = self["type"].replace(" ,",",")
-        #Optional doxygen description
-        try:
-            self["desc"] = kwargs["doxyVarDesc"][self["name"]]
-        except: pass
-
-        self.init()
-        CppVariable.Vars.append( self )        # save and resolve later
-    
-    def __repr__(self):
-        keys_white_list = ['constant','name','reference','type','static','pointer','desc', 'line_number']
-        cpy = dict((k,v) for (k,v) in list(self.items()) if k in keys_white_list)
-        if "array_size" in self: cpy["array_size"] = self["array_size"]
-        return "%s"%cpy
-
-class _CppEnum(dict):
-    def resolve_enum_values( self, values ):
-        """Evaluates the values list of dictionaries passed in and figures out what the enum value
-        for each enum is editing in place:
-        
-        Example:
-        From: [{'name': 'ORANGE'},
-               {'name': 'RED'},
-               {'name': 'GREEN', 'value': '8'}]
-        To:   [{'name': 'ORANGE', 'value': 0},
-               {'name': 'RED', 'value': 1},
-               {'name': 'GREEN', 'value': 8}]
-        """
-        t = int; i = 0
-        names = [ v['name'] for v in values ]
-        for v in values:
-            if 'value' in v:
-                a = v['value'].strip()
-                # Remove single quotes from single quoted chars (unless part of some expression
-                if len(a) == 3 and a[0] == "'" and a[2] == "'":
-                    a = v['value'] = a[1]
-                if a.lower().startswith("0x"):
-                    try:
-                        i = a = int(a , 16)
-                    except:pass
-                elif a.isdigit():
-                    i = a = int( a )
-                elif a in names:
-                    for other in values:
-                        if other['name'] == a:
-                            v['value'] = other['value']
-                            break
-
-                elif '"' in a or "'" in a: t = str # only if there are quotes it this a string enum
-                else:
-                    try:
-                        a = i = ord(a)
-                    except: pass
-                #Allow access of what is in the file pre-convert if converted
-                if v['value'] != str(a):
-                    v['raw_value'] = v['value']
-                v['value'] = a
-            else: v['value'] = i
-            try:
-                v['value'] = v['value'].replace(" < < ", " << ").replace(" >> ", " >> ")
-            except: pass
-            i += 1
-        return t
-
-class CppEnum(_CppEnum):
-    """Takes a name stack and turns it into an Enum
-    
-    Contains the following Keys:
-    self['name'] - Name of the enum (ex. "ItemState")
-    self['namespace'] - Namespace containing the enum
-    self['values'] - List of values where the values are a dictionary of the
-        form {"name": name of the key (ex. "PARSING_HEADER"),
-                  "value": Specified value of the enum, this key will only exist
-                    if a value for a given enum value was defined
-                }
-    """
-    def __init__(self, nameStack):
-        global doxygenCommentCache
-        if len(doxygenCommentCache):
-            self["doxygen"] = doxygenCommentCache
-            doxygenCommentCache = ""
-        if len(nameStack) == 3 and nameStack[0] == "enum":
-            debug_print("Created enum as just name/value")
-            self["name"] = nameStack[1]
-            self["instances"]=[nameStack[2]]
-        if len(nameStack) < 4 or "{" not in nameStack or "}" not in nameStack:
-            #Not enough stuff for an enum
-            debug_print("Bad enum")
-            return
-        valueList = []
-        self["line_number"] = detect_lineno(nameStack[0])
-        #Figure out what values it has
-        valueStack = nameStack[nameStack.index('{') + 1: nameStack.index('}')]
-        while len(valueStack):
-            tmpStack = []
-            if "," in valueStack:
-                tmpStack = valueStack[:valueStack.index(",")]
-                valueStack = valueStack[valueStack.index(",") + 1:]
-            else:
-                tmpStack = valueStack
-                valueStack = []
-            d = {}
-            if len(tmpStack) == 1: d["name"] = tmpStack[0]
-            elif len(tmpStack) >= 3 and tmpStack[1] == "=":
-                d["name"] = tmpStack[0]; d["value"] = " ".join(tmpStack[2:])
-            elif len(tmpStack) == 2 and tmpStack[1] == "=":
-                debug_print( "WARN-enum: parser missed value for %s"%tmpStack[0] )
-                d["name"] = tmpStack[0]
-
-            if d: valueList.append( d )
-
-        if len(valueList):
-            self['type'] = self.resolve_enum_values( valueList )    # returns int for standard enum
-            self["values"] = valueList
-        else:
-            warning_print( 'WARN-enum: empty enum %s'%nameStack )
-            return
-        #Figure out if it has a name
-        preBraceStack = nameStack[:nameStack.index("{")]
-        postBraceStack = nameStack[nameStack.index("}") + 1:]
-        if (len(preBraceStack) == 2 and "typedef" not in nameStack):
-            self["name"] = preBraceStack[1]           
-        elif len(postBraceStack) and "typedef" in nameStack:
-                self["name"] = " ".join(postBraceStack)
-        else: warning_print( 'WARN-enum: nameless enum %s'%nameStack )
-        #See if there are instances of this
-        if "typedef" not in nameStack and len(postBraceStack):
-            self["instances"] = []
-            for var in postBraceStack:
-                if "," in var:
-                    continue
-                self["instances"].append(var)
-        self["namespace"] = ""
-
-
-class CppStruct(dict):
-    Structs = []
-    def __init__(self, nameStack):
-        if len(nameStack) >= 2: self['type'] = nameStack[1]
-        else: self['type'] = None
-        self['fields'] = []
-        self.Structs.append( self )
-        global curLine
-        self["line_number"] = curLine
-
-C99_NONSTANDARD = {
-    'int8' : 'signed char',
-    'int16' : 'short int',
-    'int32' : 'int',
-    'int64' : 'int64_t',        # this can be: long int (64bit), or long long int (32bit)
-    'uint' : 'unsigned int',
-    'uint8' : 'unsigned char',
-    'uint16' : 'unsigned short int',
-    'uint32' : 'unsigned int',
-    'uint64' : 'uint64_t',    # depends on host bits
-}
-
-
-def standardize_fundamental( s ):
-    if s in C99_NONSTANDARD: return C99_NONSTANDARD[ s ]
-    else: return s
-
-
-class Resolver(object):
-    C_FUNDAMENTAL = 'size_t unsigned signed bool char wchar short int float double long void'.split()
-    C_FUNDAMENTAL += 'struct union enum'.split()
-
-
-    SubTypedefs = {}        # TODO deprecate?
-    NAMESPACES = []
-    CLASSES = {}
-    STRUCTS = {}
-
-    def initextra(self):
-        self.typedefs = {}
-        self.typedefs_order = []
-        self.classes_order = []
-        self.structs = Resolver.STRUCTS
-        self.structs_order = []
-        self.namespaces = Resolver.NAMESPACES        # save all namespaces
-        self.curStruct = None
-        self.stack = []    # full name stack, good idea to keep both stacks? (simple stack and full stack)
-        self._classes_brace_level = {}    # class name : level
-        self._structs_brace_level = {}        # struct type : level
-        self._method_body = None
-        self._forward_decls = []
-        self._template_typenames = []    # template<typename XXX>
-
-    def current_namespace(self): return self.cur_namespace(True)
-
-    def cur_namespace(self, add_double_colon=False):
-        rtn = ""
-        i = 0
-        while i < len(self.nameSpaces):
-            rtn += self.nameSpaces[i]
-            if add_double_colon or i < len(self.nameSpaces) - 1: rtn += "::"
-            i+=1
-        return rtn
-
-
-    def guess_ctypes_type( self, string ):
-        pointers = string.count('*')
-        string = string.replace('*','')
-
-        a = string.split()
-        if 'unsigned' in a: u = 'u'
-        else: u = ''
-        if 'long' in a and 'double' in a: b = 'longdouble'    # there is no ctypes.c_ulongdouble (this is a 64bit float?)
-        elif a.count('long') == 2 and 'int' in a: b = '%sint64' %u
-        elif a.count('long') == 2: b = '%slonglong' %u
-        elif 'long' in a: b = '%slong' %u
-        elif 'double' in a: b = 'double'    # no udouble in ctypes
-        elif 'short' in a: b = '%sshort' %u
-        elif 'char' in a: b = '%schar' %u
-        elif 'wchar' in a: b = 'wchar'
-        elif 'bool' in a: b = 'bool'
-        elif 'float' in a: b = 'float'
-
-        elif 'int' in a: b = '%sint' %u
-        elif 'int8' in a: b = 'int8'
-        elif 'int16' in a: b = 'int16'
-        elif 'int32' in a: b = 'int32'
-        elif 'int64' in a: b = 'int64'
-
-        elif 'uint' in a: b = 'uint'
-        elif 'uint8' in a: b = 'uint8'
-        elif 'uint16' in a: b = 'uint16'
-        elif 'uint32' in a: b = 'uint32'
-        elif 'uint64' in a: b = 'uint64'
-
-        elif 'size_t' in a: b = 'size_t'
-        elif 'void' in a: b = 'void_p'
-
-        elif string in 'struct union'.split(): b = 'void_p'    # what should be done here? don't trust struct, it could be a class, no need to expose via ctypes
-        else: b = 'void_p'
-
-        if not pointers: return 'ctypes.c_%s' %b
-        else:
-            x = ''
-            for i in range(pointers): x += 'ctypes.POINTER('
-            x += 'ctypes.c_%s' %b
-            x += ')' * pointers
-            return x
-
-    def resolve_type( self, string, result ):    # recursive
-        '''
-        keeps track of useful things like: how many pointers, number of typedefs, is fundamental or a class, etc...
-        '''
-        ## be careful with templates, what is inside <something*> can be a pointer but the overall type is not a pointer
-        ## these come before a template
-        s = string.split('<')[0]
-        result[ 'constant' ] += s.split().count('const')
-        result[ 'static' ] += s.split().count('static')
-        result[ 'mutable' ] = 'mutable' in s.split()
-
-        ## these come after a template
-        s = string.split('>')[-1]
-        result[ 'pointer' ] += s.count('*')
-        result[ 'reference' ] += s.count('&')
-
-
-        x = string; alias = False
-        for a in '* & const static mutable'.split(): x = x.replace(a,'')
-        for y in x.split():
-            if y not in self.C_FUNDAMENTAL: alias = y; break
-
-        #if alias == 'class':
-        #    result['class'] = result['name']    # forward decl of class
-        #    result['forward_decl'] = True
-        if alias == '__extension__': result['fundamental_extension'] = True
-        elif alias:
-            result['aliases'].append( alias )
-            if alias in C99_NONSTANDARD:
-                result['type'] = C99_NONSTANDARD[ alias ]
-                result['typedef'] = alias
-                result['typedefs'] += 1
-            elif alias in self.typedefs:
-                result['typedefs'] += 1
-                result['typedef'] = alias
-                self.resolve_type( self.typedefs[alias], result )
-            elif alias in self.classes:
-                klass = self.classes[alias]; result['fundamental'] = False
-                result['class'] = klass
-                result['unresolved'] = False
-            else: result['unresolved'] = True
-        else:
-            result['fundamental'] = True
-            result['unresolved'] = False
-
-
-    def finalize_vars(self):
-        for s in CppStruct.Structs:    # vars within structs can be ignored if they do not resolve
-            for var in s['fields']: var['parent'] = s['type']
-        #for c in self.classes.values():
-        #    for var in c.get_all_properties(): var['parent'] = c['name']
-
-        ## RESOLVE ##
-        for var in CppVariable.Vars:
-            self.resolve_type( var['type'], var )
-            #if 'method' in var and var['method']['name'] ==  '_notifyCurrentCamera': print(var); assert 0
-
-        # then find concrete type and best guess ctypes type #
-        for var in CppVariable.Vars:    
-            if not var['aliases']:    #var['fundamental']:
-                var['ctypes_type'] = self.guess_ctypes_type( var['type'] )
-            else:
-                var['unresolved'] = False    # below may test to True
-                if var['class']:
-                    var['ctypes_type'] = 'ctypes.c_void_p'
-                else:
-                    assert var['aliases']
-                    tag = var['aliases'][0]
-
-                    klass = None
-                    nestedEnum = None
-                    nestedStruct = None
-                    nestedTypedef = None
-                    if 'method' in var and 'parent' in list(var['method'].keys()):
-                        klass = var['method']['parent']
-                        if tag in var['method']['parent']._public_enums:
-                            nestedEnum = var['method']['parent']._public_enums[ tag ]
-                        elif tag in var['method']['parent']._public_structs:
-                            nestedStruct = var['method']['parent']._public_structs[ tag ]
-                        elif tag in var['method']['parent']._public_typedefs:
-                            nestedTypedef = var['method']['parent']._public_typedefs[ tag ]
-
-
-                    if '<' in tag:    # should also contain '>'
-                        var['template'] = tag        # do not resolve templates
-                        var['ctypes_type'] = 'ctypes.c_void_p'
-                        var['unresolved'] = True
-
-                    elif nestedEnum:
-                        enum = nestedEnum
-                        if enum['type'] is int:
-                            var['ctypes_type'] = 'ctypes.c_int'
-                            var['raw_type'] = 'int'
-
-                        elif enum['type'] is str:
-                            var['ctypes_type'] = 'ctypes.c_char_p'
-                            var['raw_type'] = 'char*'
-
-                        var['enum'] = var['method']['path'] + '::' + enum['name']
-                        var['fundamental'] = True
-
-                    elif nestedStruct:
-                        var['ctypes_type'] = 'ctypes.c_void_p'
-                        var['raw_type'] = var['method']['path'] + '::' + nestedStruct['type']
-                        var['fundamental'] = False
-
-                    elif nestedTypedef:
-                        var['fundamental'] = is_fundamental( nestedTypedef )
-                        if not var['fundamental']:
-                            var['raw_type'] = var['method']['path'] + '::' + tag
-
-                    else:
-                        _tag = tag
-                        if '::' in tag and tag.split('::')[0] in self.namespaces: tag = tag.split('::')[-1]
-                        con = self.concrete_typedef( _tag )
-                        if con:
-                            var['concrete_type'] = con
-                            var['ctypes_type'] = self.guess_ctypes_type( var['concrete_type'] )
-
-                        elif tag in self.structs:
-                            trace_print( 'STRUCT', var )
-                            var['struct'] = tag
-                            var['ctypes_type'] = 'ctypes.c_void_p'
-                            var['raw_type'] = self.structs[tag]['namespace'] + '::' + tag
-
-                        elif tag in self._forward_decls:
-                            var['forward_declared'] = tag
-                            var['ctypes_type'] = 'ctypes.c_void_p'
-
-                        elif tag in self.global_enums:
-                            enum = self.global_enums[ tag ]
-                            if enum['type'] is int:
-                                var['ctypes_type'] = 'ctypes.c_int'
-                                var['raw_type'] = 'int'
-                            elif enum['type'] is str:
-                                var['ctypes_type'] = 'ctypes.c_char_p'
-                                var['raw_type'] = 'char*'
-                            var['enum'] = enum['namespace'] + enum['name']
-                            var['fundamental'] = True
-
-
-                        elif var['parent']:
-                            warning_print( 'WARN unresolved %s'%_tag)
-                            var['ctypes_type'] = 'ctypes.c_void_p'
-                            var['unresolved'] = True
-
-
-                        elif tag.count('::')==1:
-                            trace_print( 'trying to find nested something in', tag )
-                            a = tag.split('::')[0]
-                            b = tag.split('::')[-1]
-                            if a in self.classes:    # a::b is most likely something nested in a class
-                                klass = self.classes[ a ]
-                                if b in klass._public_enums:
-                                    trace_print( '...found nested enum', b )
-                                    enum = klass._public_enums[ b ]
-                                    if enum['type'] is int:
-                                        var['ctypes_type'] = 'ctypes.c_int'
-                                        var['raw_type'] = 'int'
-                                    elif enum['type'] is str:
-                                        var['ctypes_type'] = 'ctypes.c_char_p'
-                                        var['raw_type'] = 'char*'
-                                    try:
-                                        if 'method' in var: var['enum'] = var['method']['path'] + '::' + enum['name']
-                                        else:    # class property
-                                            var['unresolved'] = True
-                                    except:
-                                        var['unresolved'] = True
-                                        
-                                    var['fundamental'] = True
-
-                                else: var['unresolved'] = True    # TODO klass._public_xxx
-
-                            elif a in self.namespaces:    # a::b can also be a nested namespace
-                                if b in self.global_enums:
-                                    enum = self.global_enums[ b ]
-                                    trace_print(enum)
-                                trace_print(var)
-                                assert 0
-
-                            elif b in self.global_enums:        # falling back, this is a big ugly
-                                enum = self.global_enums[ b ]
-                                assert a in enum['namespace'].split('::')
-                                if enum['type'] is int:
-                                    var['ctypes_type'] = 'ctypes.c_int'
-                                    var['raw_type'] = 'int'
-                                elif enum['type'] is str:
-                                    var['ctypes_type'] = 'ctypes.c_char_p'
-                                    var['raw_type'] = 'char*'
-                                var['fundamental'] = True
-
-                            else:    # boost::gets::crazy
-                                trace_print('NAMESPACES', self.namespaces)
-                                trace_print( a, b )
-                                trace_print( '---- boost gets crazy ----' )
-                                var['ctypes_type'] = 'ctypes.c_void_p'
-                                var['unresolved'] = True
-
-
-                        elif 'namespace' in var and self.concrete_typedef(var['namespace']+tag):
-                            #print( 'TRYING WITH NS', var['namespace'] )
-                            con = self.concrete_typedef( var['namespace']+tag )
-                            if con:
-                                var['typedef'] = var['namespace']+tag
-                                var['type'] = con
-                                if 'struct' in con.split():
-                                    var['raw_type'] = var['typedef']
-                                    var['ctypes_type'] = 'ctypes.c_void_p'
-                                else:
-                                    self.resolve_type( var['type'], var )
-                                    var['ctypes_type'] = self.guess_ctypes_type( var['type'] )
-
-                        elif '::' in var:
-                            var['ctypes_type'] = 'ctypes.c_void_p'
-                            var['unresolved'] = True
-
-                        elif tag in self.SubTypedefs:    # TODO remove SubTypedefs
-                            if 'property_of_class' in var or 'property_of_struct' in var:
-                                trace_print( 'class:', self.SubTypedefs[ tag ], 'tag:', tag )
-                                var['typedef'] = self.SubTypedefs[ tag ]    # class name
-                                var['ctypes_type'] = 'ctypes.c_void_p'
-                            else:
-                                trace_print( "WARN-this should almost never happen!" )
-                                trace_print( var ); trace_print('-'*80)
-                                var['unresolved'] = True
-
-                        elif tag in self._template_typenames:
-                            var['typename'] = tag
-                            var['ctypes_type'] = 'ctypes.c_void_p'
-                            var['unresolved'] = True    # TODO, how to deal with templates?
-
-                        elif tag.startswith('_'):    # assume starting with underscore is not important for wrapping
-                            warning_print( 'WARN unresolved %s'%_tag)
-                            var['ctypes_type'] = 'ctypes.c_void_p'
-                            var['unresolved'] = True
-
-                        else:
-                            trace_print( 'WARN: unknown type', var )
-                            assert 'property_of_class' in var or 'property_of_struct'    # only allow this case
-                            var['unresolved'] = True
-
-
-                    ## if not resolved and is a method param, not going to wrap these methods  ##
-                    if var['unresolved'] and 'method' in var: var['method']['unresolved_parameters'] = True
-
-
-        # create stripped raw_type #
-        p = '* & const static mutable'.split()        # +++ new July7: "mutable"
-        for var in CppVariable.Vars:
-            if 'raw_type' not in var:
-                raw = []
-                for x in var['type'].split():
-                    if x not in p: raw.append( x )
-                var['raw_type'] = ' '.join( raw )
-
-                #if 'AutoConstantEntry' in var['raw_type']: print(var); assert 0
-                if var['class']:
-                    if '::' not in var['raw_type']:
-                        if not var['class']['parent']:
-                            var['raw_type'] = var['class']['namespace'] + '::' + var['raw_type']
-                        elif var['class']['parent'] in self.classes:
-                            parent = self.classes[ var['class']['parent'] ]
-                            var['raw_type'] = parent['namespace'] + '::' + var['class']['name'] + '::' + var['raw_type']
-                        else:
-                            var['unresolved'] = True
-
-                    elif '::' in var['raw_type'] and var['raw_type'].split('::')[0] not in self.namespaces:
-                        var['raw_type'] = var['class']['namespace'] + '::' + var['raw_type']
-                    else:
-                        var['unresolved'] = True
-
-                elif 'forward_declared' in var and 'namespace' in var:
-                    if '::' not in var['raw_type']:
-                        var['raw_type'] = var['namespace'] + var['raw_type']
-                    elif '::' in var['raw_type'] and var['raw_type'].split('::')[0] in self.namespaces:
-                        pass
-                    else: trace_print('-'*80); trace_print(var); raise NotImplemented
-
-
-            ## need full name space for classes in raw type ##
-            if var['raw_type'].startswith( '::' ):
-                #print(var)
-                #print('NAMESPACE', var['class']['namespace'])
-                #print( 'PARENT NS', var['class']['parent']['namespace'] )
-                #assert 0
-                var['unresolved'] = True
-                if 'method' in var: var['method']['unresolved_parameters'] = True
-                #var['raw_type'] = var['raw_type'][2:]
-        
-        # Take care of #defines and #pragmas etc
-        trace_print("Processing precomp_macro_buf: %s"%self._precomp_macro_buf)
-        for m in self._precomp_macro_buf:
-            macro = m.replace("<CppHeaderParser_newline_temp_replacement>\\n", "\n")
-            try:
-                if macro.lower().startswith("#define"):
-                    trace_print("Adding #define %s"%macro)
-                    self.defines.append(macro.split(" ", 1)[1].strip())
-                elif macro.lower().startswith("#pragma"):
-                    trace_print("Adding #pragma %s"%macro)
-                    self.pragmas.append(macro.split(" ", 1)[1].strip())
-                elif macro.lower().startswith("#include"):
-                    trace_print("Adding #include %s"%macro)
-                    self.includes.append(macro.split(" ", 1)[1].strip())
-                else:
-                    debug_print("Cant detect what to do with precomp macro '%s'"%macro)
-            except: pass
-        self._precomp_macro_buf = None
-        
-
-    def concrete_typedef( self, key ):
-        if key not in self.typedefs:
-            #print( 'FAILED typedef', key )
-            return None
-        while key in self.typedefs:
-            prev = key
-            key = self.typedefs[ key ]
-            if '<' in key or '>' in key: return prev        # stop at template
-            if key.startswith('std::'): return key        # stop at std lib
-        return key
-
-
-class _CppHeader( Resolver ):
-    def finalize(self):
-        self.finalize_vars()
-        # finalize classes and method returns types
-        for cls in list(self.classes.values()):
-            for meth in cls.get_all_methods():
-                if meth['pure_virtual']: cls['abstract'] = True
-
-                if not meth['returns_fundamental'] and meth['returns'] in C99_NONSTANDARD:
-                    meth['returns'] = C99_NONSTANDARD[meth['returns']]
-                    meth['returns_fundamental'] = True
-
-                elif not meth['returns_fundamental']:    # describe the return type
-                    con = None
-                    if cls['namespace'] and '::' not in meth['returns']:
-                        con = self.concrete_typedef( cls['namespace'] + '::' + meth['returns'] )
-                    else: con = self.concrete_typedef( meth['returns'] )
-
-
-                    if con:
-                        meth['returns_concrete'] = con
-                        meth['returns_fundamental'] = is_fundamental( con )
-
-                    elif meth['returns'] in self.classes:
-                        trace_print( 'meth returns class:', meth['returns'] )
-                        meth['returns_class'] = True
-
-                    elif meth['returns'] in self.SubTypedefs:
-                        meth['returns_class'] = True
-                        meth['returns_nested'] = self.SubTypedefs[ meth['returns'] ]
-
-                    elif meth['returns'] in cls._public_enums:
-                        enum = cls._public_enums[ meth['returns'] ]
-                        meth['returns_enum'] = enum['type']
-                        meth['returns_fundamental'] = True
-                        if enum['type'] == int: meth['returns'] = 'int'
-                        else: meth['returns'] = 'char*'
-
-                    elif meth['returns'] in self.global_enums:
-                        enum = self.global_enums[ meth['returns'] ]
-                        meth['returns_enum'] = enum['type']
-                        meth['returns_fundamental'] = True
-                        if enum['type'] == int: meth['returns'] = 'int'
-                        else: meth['returns'] = 'char*'
-
-                    elif meth['returns'].count('::')==1:
-                        trace_print( meth )
-                        a,b = meth['returns'].split('::')
-                        if a in self.namespaces:
-                            if b in self.classes:
-                                klass = self.classes[ b ]
-                                meth['returns_class'] = a + '::' + b
-                            elif '<' in b and '>' in b:
-                                warning_print( 'WARN-can not return template: %s'%b )
-                                meth['returns_unknown'] = True
-                            elif b in self.global_enums:
-                                enum = self.global_enums[ b ]
-                                meth['returns_enum'] = enum['type']
-                                meth['returns_fundamental'] = True
-                                if enum['type'] == int: meth['returns'] = 'int'
-                                else: meth['returns'] = 'char*'
-
-                            else: trace_print( a, b); trace_print( meth); meth['returns_unknown'] = True    # +++
-
-                        elif a in self.classes:
-                            klass = self.classes[ a ]
-                            if b in klass._public_enums:
-                                trace_print( '...found nested enum', b )
-                                enum = klass._public_enums[ b ]
-                                meth['returns_enum'] = enum['type']
-                                meth['returns_fundamental'] = True
-                                if enum['type'] == int: meth['returns'] = 'int'
-                                else: meth['returns'] = 'char*'
-
-                            elif b in klass._public_forward_declares:
-                                meth['returns_class'] = True
-
-                            elif b in klass._public_typedefs:
-                                typedef = klass._public_typedefs[ b ]
-                                meth['returns_fundamental'] = is_fundamental( typedef )
-
-                            else:
-                                trace_print( meth )    # should be a nested class, TODO fix me.
-                                meth['returns_unknown'] = True
-
-                    elif '::' in meth['returns']:
-                        trace_print('TODO namespace or extra nested return:', meth)
-                        meth['returns_unknown'] = True
-                    else:
-                        trace_print( 'WARN: UNKNOWN RETURN', meth['name'], meth['returns'])
-                        meth['returns_unknown'] = True
-
-        for cls in list(self.classes.values()):
-            methnames = cls.get_all_method_names()
-            pvm = cls.get_all_pure_virtual_methods()
-
-            for d in cls['inherits']:
-                c = d['class']
-                a = d['access']    # do not depend on this to be 'public'
-                trace_print( 'PARENT CLASS:', c )
-                if c not in self.classes: trace_print('WARN: parent class not found')
-                if c in self.classes and self.classes[c]['abstract']:
-                    p = self.classes[ c ]
-                    for meth in p.get_all_methods():    #p["methods"]["public"]:
-                        trace_print( '\t\tmeth', meth['name'], 'pure virtual', meth['pure_virtual'] )
-                        if meth['pure_virtual'] and meth['name'] not in methnames: cls['abstract'] = True; break
-
-
-
-
-
-    def evaluate_struct_stack(self):
-        """Create a Struct out of the name stack (but not its parts)"""
-        #print( 'eval struct stack', self.nameStack )
-        #if self.braceDepth != len(self.nameSpaces): return
-        struct = CppStruct(self.nameStack)
-        struct["namespace"] = self.cur_namespace()
-        self.structs[ struct['type'] ] = struct
-        self.structs_order.append( struct )
-        if self.curClass:
-            struct['parent'] = self.curClass
-            klass = self.classes[ self.curClass ]
-            klass['structs'][self.curAccessSpecifier].append( struct )
-            if self.curAccessSpecifier == 'public': klass._public_structs[ struct['type'] ] = struct
-        self.curStruct = struct
-        self._structs_brace_level[ struct['type'] ] = self.braceDepth
-
-    
-    def parse_method_type( self, stack ):
-        trace_print( 'meth type info', stack )
-        if stack[0] in ':;': stack = stack[1:]
-        info = { 
-            'debug': ' '.join(stack).replace(' : : ', '::' ).replace(' < ', '<' ).replace(' > ', '> ' ).replace(" >",">").replace(">>", "> >").replace(">>", "> >"), 
-            'class':None, 
-            'namespace':self.cur_namespace(add_double_colon=True),
-        }
-
-        for tag in 'defined pure_virtual operator constructor destructor extern template virtual static explicit inline friend returns returns_pointer returns_fundamental returns_class'.split(): info[tag]=False
-        header = stack[ : stack.index('(') ]
-        header = ' '.join( header )
-        header = header.replace(' : : ', '::' )
-        header = header.replace(' < ', '<' )
-        header = header.replace(' > ', '> ' )
-        header = header.strip()
-
-        if '{' in stack:
-            info['defined'] = True
-            self._method_body = self.braceDepth + 1
-            trace_print( 'NEW METHOD WITH BODY', self.braceDepth )
-        elif stack[-1] == ';':
-            info['defined'] = False
-            self._method_body = None    # not a great idea to be clearing here
-        else: assert 0
-
-        if len(stack) > 3 and stack[-1] == ';' and stack[-2] == '0' and stack[-3] == '=':
-            info['pure_virtual'] = True
-
-        r = header.split()
-        name = None
-        if 'operator' in stack:    # rare case op overload defined outside of class
-            op = stack[ stack.index('operator')+1 : stack.index('(') ]
-            op = ''.join(op)
-            if not op:
-                if " ".join(['operator', '(', ')', '(']) in " ".join(stack):
-                    op = "()"
-                else:
-                    trace_print( 'Error parsing operator')
-                    return None
-            
-            info['operator'] = op
-            name = 'operator' + op
-            a = stack[ : stack.index('operator') ]
-
-        elif r:
-            name = r[-1]
-            a = r[ : -1 ]    # strip name
-
-        if name is None: return None
-        #if name.startswith('~'): name = name[1:]
-
-        while a and a[0] == '}':    # strip - can have multiple } }
-            a = a[1:]
-
-
-        if '::' in name:
-            #klass,name = name.split('::')    # methods can be defined outside of class
-            klass = name[ : name.rindex('::') ]
-            name = name.split('::')[-1]
-            info['class'] = klass
-            if klass in self.classes and not self.curClass:
-                 #Class function defined outside the class
-                return None
-        #    info['name'] = name
-        #else: info['name'] = name
-
-        if name.startswith('~'):
-            info['destructor'] = True
-            name = name[1:]
-        elif not a or (name == self.curClass and len(self.curClass)):
-            info['constructor'] = True
-
-        info['name'] = name
-
-        for tag in 'extern virtual static explicit inline friend'.split():
-            if tag in a: info[ tag ] = True; a.remove( tag )    # inplace
-        if 'template' in a:
-            a.remove('template')
-            b = ' '.join( a )
-            if '>' in b:
-                info['template'] = b[ : b.index('>')+1 ]
-                info['returns'] = b[ b.index('>')+1 : ]    # find return type, could be incorrect... TODO
-                if '<typename' in info['template'].split():
-                    typname = info['template'].split()[-1]
-                    typname = typname[ : -1 ]    # strip '>'
-                    if typname not in self._template_typenames: self._template_typenames.append( typname )
-            else: info['returns'] = ' '.join( a )
-        else: info['returns'] = ' '.join( a )
-        info['returns'] = info['returns'].replace(' <', '<').strip()
-
-        ## be careful with templates, do not count pointers inside template
-        info['returns_pointer'] = info['returns'].split('>')[-1].count('*')
-        if info['returns_pointer']: info['returns'] = info['returns'].replace('*','').strip()
-
-        info['returns_reference'] = '&' in info['returns']
-        if info['returns']: info['returns'] = info['returns'].replace('&','').strip()
-
-        a = []
-        for b in info['returns'].split():
-            if b == '__const__': info['returns_const'] = True
-            elif b == 'const': info['returns_const'] = True
-            else: a.append( b )
-        info['returns'] = ' '.join( a )
-
-        info['returns_fundamental'] = is_fundamental( info['returns'] )
-        return info
-
-    def evaluate_method_stack(self):
-        """Create a method out of the name stack"""
-
-        if self.curStruct:
-            trace_print( 'WARN - struct contains methods - skipping' )
-            trace_print( self.stack )
-            assert 0
-
-        info = self.parse_method_type( self.stack )
-        if info:
-            if info[ 'class' ] and info['class'] in self.classes:     # case where methods are defined outside of class
-                newMethod = CppMethod(self.nameStack, info['name'], info)
-                klass = self.classes[ info['class'] ]
-                klass[ 'methods' ][ 'public' ].append( newMethod )
-                newMethod['parent'] = klass
-                if klass['namespace']: newMethod['path'] = klass['namespace'] + '::' + klass['name']
-                else: newMethod['path'] = klass['name']
-                
-            elif self.curClass:    # normal case
-                newMethod = CppMethod(self.nameStack, self.curClass, info)
-                klass = self.classes[self.curClass]
-                klass['methods'][self.curAccessSpecifier].append(newMethod)
-                newMethod['parent'] = klass
-                if klass['namespace']: newMethod['path'] = klass['namespace'] + '::' + klass['name']
-                else: newMethod['path'] = klass['name']
-            else: #non class functions
-                debug_print("FREE FUNCTION")
-                newMethod = CppMethod(self.nameStack, None, info)
-                self.functions.append(newMethod)
-            global parseHistory
-            parseHistory.append({"braceDepth": self.braceDepth, "item_type": "method", "item": newMethod})
-        else:
-            trace_print( 'free function?', self.nameStack )
-
-        self.stack = []
-
-    def _parse_typedef( self, stack, namespace='' ):
-        if not stack or 'typedef' not in stack: return
-        stack = list( stack )    # copy just to be safe
-        if stack[-1] == ';': stack.pop()
-
-        while stack and stack[-1].isdigit(): stack.pop()    # throw away array size for now
-
-        idx = stack.index('typedef')
-        name = namespace + stack[-1]
-        s = ''
-        for a in stack[idx+1:-1]:
-            if a == '{': break
-            if not s or s[-1] in ':<>' or a in ':<>': s += a    # keep compact
-            else: s += ' ' + a    # spacing
-
-        r = {'name':name, 'raw':s, 'type':s}
-        if not is_fundamental(s):
-            if 'struct' in s.split(): pass        # TODO is this right? "struct ns::something"
-            elif '::' not in s: s = namespace + s         # only add the current name space if no namespace given
-            r['type'] = s
-        if s: return r
-
-
-    def evaluate_typedef(self):
-        ns = self.cur_namespace(add_double_colon=True)
-        res = self._parse_typedef( self.stack, ns )
-        if res:
-            name = res['name']
-            self.typedefs[ name ] = res['type']
-            if name not in self.typedefs_order: self.typedefs_order.append( name )
-
-
-    def evaluate_property_stack(self):
-        """Create a Property out of the name stack"""
-        global parseHistory
-        assert self.stack[-1] == ';'
-        if self.nameStack[0] == 'typedef':
-            if self.curClass:
-                typedef = self._parse_typedef( self.stack )
-                name = typedef['name']
-                klass = self.classes[ self.curClass ]
-                klass[ 'typedefs' ][ self.curAccessSpecifier ].append( name )
-                if self.curAccessSpecifier == 'public': klass._public_typedefs[ name ] = typedef['type']
-                Resolver.SubTypedefs[ name ] = self.curClass
-            else: assert 0
-        elif self.curStruct or self.curClass:
-            if len(self.nameStack) == 1:
-                #See if we can de anonymize the type
-                filteredParseHistory = [h for h in parseHistory if h["braceDepth"] == self.braceDepth]
-                if len(filteredParseHistory) and filteredParseHistory[-1]["item_type"] == "class":
-                    self.nameStack.insert(0, filteredParseHistory[-1]["item"]["name"])
-                    debug_print("DEANONYMOIZING %s to type '%s'"%(self.nameStack[1], self.nameStack[0]))
-            newVar = CppVariable(self.nameStack)
-            newVar['namespace'] = self.current_namespace()
-            if self.curStruct:
-                self.curStruct[ 'fields' ].append( newVar )
-                newVar['property_of_struct'] = self.curStruct
-            elif self.curClass:
-                klass = self.classes[self.curClass]
-                klass["properties"][self.curAccessSpecifier].append(newVar)
-                newVar['property_of_class'] = klass['name']
-            parseHistory.append({"braceDepth": self.braceDepth, "item_type": "variable", "item": newVar})
-
-        self.stack = []        # CLEAR STACK
-
-    def evaluate_class_stack(self):
-        """Create a Class out of the name stack (but not its parts)"""
-        #dont support sub classes today
-        #print( 'eval class stack', self.nameStack )
-        parent = self.curClass
-        if self.braceDepth > len( self.nameSpaces) and parent:
-            trace_print( 'HIT NESTED SUBCLASS' )
-            self.accessSpecifierStack.append(self.curAccessSpecifier)
-        elif self.braceDepth != len(self.nameSpaces):
-            error_print( 'ERROR: WRONG BRACE DEPTH' )
-            return
-        
-        if self.nameStack[0] == "class":
-            self.curAccessSpecifier = 'private'
-        else:#struct
-            self.curAccessSpecifier = 'public'
-        debug_print("curAccessSpecifier changed/defaulted to %s"%self.curAccessSpecifier)
-        if self.nameStack[0] == "union":
-            newClass = CppUnion(self.nameStack)
-            self.anon_union_counter = [self.braceDepth, 2]
-            trace_print( 'NEW UNION', newClass['name'] )
-        else:
-            newClass = CppClass(self.nameStack)
-            trace_print( 'NEW CLASS', newClass['name'] )
-        newClass["declaration_method"] = self.nameStack[0]
-        self.classes_order.append( newClass )    # good idea to save ordering
-        self.stack = []        # fixes if class declared with ';' in closing brace
-        if parent:
-            newClass["namespace"] = self.classes[ parent ]['namespace'] + '::' + parent
-            newClass['parent'] = parent
-            self.classes[ parent ]['nested_classes'].append( newClass )
-            ## supports nested classes with the same name ##
-            self.curClass = key = parent+'::'+newClass['name']
-            self._classes_brace_level[ key ] = self.braceDepth
-
-        elif newClass['parent']:        # nested class defined outside of parent.  A::B {...}
-            parent = newClass['parent']
-            newClass["namespace"] = self.classes[ parent ]['namespace'] + '::' + parent
-            self.classes[ parent ]['nested_classes'].append( newClass )
-            ## supports nested classes with the same name ##
-            self.curClass = key = parent+'::'+newClass['name']
-            self._classes_brace_level[ key ] = self.braceDepth
-
-        else:
-            newClass["namespace"] = self.cur_namespace()
-            key = newClass['name']
-            self.curClass = newClass["name"]
-            self._classes_brace_level[ newClass['name'] ] = self.braceDepth
-
-        if not key.endswith("::") and not key.endswith(" ") and len(key) != 0:
-            if key in self.classes:
-                trace_print( 'ERROR name collision:', key )
-                self.classes[key].show()
-                trace_print('-'*80)
-                newClass.show()            
-                assert key not in self.classes    # namespace collision
-        self.classes[ key ] = newClass
-        global parseHistory
-        parseHistory.append({"braceDepth": self.braceDepth, "item_type": "class", "item": newClass})
-    
-
-    def evalute_forward_decl(self):
-        trace_print( 'FORWARD DECL', self.nameStack )
-        assert self.nameStack[0] in ('class', 'struct')
-        name = self.nameStack[-1]
-        if self.curClass:
-            klass = self.classes[ self.curClass ]
-            klass['forward_declares'][self.curAccessSpecifier].append( name )
-            if self.curAccessSpecifier == 'public': klass._public_forward_declares.append( name )
-        else: self._forward_decls.append( name )
-
-class CppHeader( _CppHeader ):
-    """Parsed C++ class header
-    
-    Variables produced:
-    self.classes - Dictionary of classes found in a given header file where the
-        key is the name of the class
-    """
-    IGNORE_NAMES = '__extension__'.split()
-   
-    def show(self):
-        for className in list(self.classes.keys()):self.classes[className].show()
-
-    def __init__(self, headerFileName, argType="file", **kwargs):
-        """Create the parsed C++ header file parse tree
-        
-        headerFileName - Name of the file to parse OR actual file contents (depends on argType)
-        argType - Indicates how to interpret headerFileName as a file string or file name
-        kwargs - Supports the following keywords
-        """
-        ## reset global state ##
-        global doxygenCommentCache
-        doxygenCommentCache = ""
-        CppVariable.Vars = []
-        CppStruct.Structs = []
-
-        if (argType == "file"):
-            self.headerFileName = os.path.expandvars(headerFileName)
-            self.mainClass = os.path.split(self.headerFileName)[1][:-2]
-            headerFileStr = ""
-        elif argType == "string":
-            self.headerFileName = ""
-            self.mainClass = "???"
-            headerFileStr = headerFileName
-        else:
-            raise Exception("Arg type must be either file or string")
-        self.curClass = ""
-       
-        # nested classes have parent::nested, but no extra namespace,
-        # this keeps the API compatible, TODO proper namespace for everything. 
-        Resolver.CLASSES = {}
-        self.classes = Resolver.CLASSES
-        #Functions that are not part of a class
-        self.functions = []
-        
-        self.pragmas = []
-        self.defines = []
-        self.includes = []
-        self._precomp_macro_buf = [] #for internal purposes, will end up filling out pragmras and defines at the end
-
-        self.enums = []
-        self.global_enums = {}
-        self.nameStack = []
-        self.nameSpaces = []
-        self.curAccessSpecifier = 'private'    # private is default
-        self.accessSpecifierStack = []
-        self.accessSpecifierScratch = []
-        debug_print("curAccessSpecifier changed/defaulted to %s"%self.curAccessSpecifier)
-        self.initextra()
-    
-        self.anon_union_counter = [-1, 0]
-    
-        if (len(self.headerFileName)):
-            fd = open(self.headerFileName)
-            headerFileStr = "".join(fd.readlines())
-            fd.close()     
-        
-        # Make sure supportedAccessSpecifier are sane
-        for i in range(0, len(supportedAccessSpecifier)):
-            if " " not in supportedAccessSpecifier[i]: continue
-            supportedAccessSpecifier[i] = re.sub("[ ]+", " ", supportedAccessSpecifier[i]).strip()
-        
-        # Strip out template declarations
-        headerFileStr = re.sub("template[\t ]*<[^>]*>", "", headerFileStr)
-
-        # Change multi line #defines and expressions to single lines maintaining line nubmers
-        # Based from http://stackoverflow.com/questions/2424458/regular-expression-to-match-cs-multiline-preprocessor-statements
-        matches = re.findall(r'(?m)^(?:.*\\\r?\n)+.*$', headerFileStr)
-        is_define = re.compile(r'[ \t\v]*#[Dd][Ee][Ff][Ii][Nn][Ee]')
-        for m in matches:
-            #Keep the newlines so that linecount doesnt break
-            num_newlines = len([a for a in m if a=="\n"])
-            if is_define.match(m):
-                new_m = m.replace("\n", "<CppHeaderParser_newline_temp_replacement>\\n")
-            else:
-                # Just expression taking up multiple lines, make it take 1 line for easier parsing
-                new_m = m.replace("\\\n", " ")
-            if (num_newlines > 1):
-                new_m += "\n"*(num_newlines)
-            headerFileStr = headerFileStr.replace(m, new_m)
-        
-        #Filter out Extern "C" statements.  These are order dependent
-        matches = re.findall(re.compile(r'extern[\t ]+"[Cc]"[\t \n\r]*{', re.DOTALL), headerFileStr)
-        for m in matches:
-            #Keep the newlines so that linecount doesnt break
-            num_newlines = len([a for a in m if a=="\n"])
-            headerFileStr = headerFileStr.replace(m, "\n" * num_newlines)        
-        headerFileStr = re.sub(r'extern[ ]+"[Cc]"[ ]*', "", headerFileStr)
-                
-        self.braceDepth = 0
-        lex.lex()
-        lex.input(headerFileStr)
-        global curLine
-        global curChar
-        curLine = 0
-        curChar = 0
-        try:
-            while True:
-                tok = lex.token()
-                if not tok: break
-                if self.anon_union_counter[0] == self.braceDepth and self.anon_union_counter[1]:
-                    self.anon_union_counter[1] -= 1
-                tok.value = TagStr(tok.value, lineno=tok.lineno)
-                #debug_print("TOK: %s"%tok)
-                if tok.type == 'NAME' and tok.value in self.IGNORE_NAMES: continue
-                self.stack.append( tok.value )
-                curLine = tok.lineno
-                curChar = tok.lexpos
-                if (tok.type in ('PRECOMP_MACRO', 'PRECOMP_MACRO_CONT')):
-                    debug_print("PRECOMP: %s"%tok)
-                    self._precomp_macro_buf.append(tok.value)
-                    continue
-                if (tok.type == 'OPEN_BRACE'):
-                    if len(self.nameStack) >= 2 and is_namespace(self.nameStack):    # namespace {} with no name used in boost, this sets default?
-                        if self.nameStack[1] == "__IGNORED_NAMESPACE__CppHeaderParser__":#Used in filtering extern "C"
-                            self.nameStack[1] = ""
-                        self.nameSpaces.append(self.nameStack[1])
-                        ns = self.cur_namespace(); self.stack = []
-                        if ns not in self.namespaces: self.namespaces.append( ns )
-                    if len(self.nameStack) and not is_enum_namestack(self.nameStack):
-                        self.evaluate_stack()
-                    else:
-                        self.nameStack.append(tok.value)
-                    if self.stack and self.stack[0] == 'class': self.stack = []
-                    self.braceDepth += 1
-                    
-                elif (tok.type == 'CLOSE_BRACE'):
-                    if self.braceDepth == 0:
-                        continue
-                    if (self.braceDepth == len(self.nameSpaces)):
-                        tmp = self.nameSpaces.pop()
-                        self.stack = []    # clear stack when namespace ends?
-                    if len(self.nameStack) and is_enum_namestack(self.nameStack):
-                        self.nameStack.append(tok.value)
-                    elif self.braceDepth < 10:
-                        self.evaluate_stack()
-                    else:
-                        self.nameStack = []
-                    self.braceDepth -= 1
-                    #self.stack = []; print 'BRACE DEPTH', self.braceDepth, 'NS', len(self.nameSpaces)
-                    if self.curClass: debug_print( 'CURBD %s'%self._classes_brace_level[ self.curClass ] )
-
-                    if (self.braceDepth == 0) or (self.curClass and self._classes_brace_level[self.curClass]==self.braceDepth):
-                        trace_print( 'END OF CLASS DEF' )
-                        if self.accessSpecifierStack:
-                            self.curAccessSpecifier = self.accessSpecifierStack[-1]
-                            self.accessSpecifierStack = self.accessSpecifierStack[:-1] 
-                        if self.curClass and self.classes[ self.curClass ]['parent']: self.curClass = self.classes[ self.curClass ]['parent']
-                        else: self.curClass = ""; #self.curStruct = None
-                        self.stack = []
-
-                    #if self.curStruct: self.curStruct = None
-                    if self.braceDepth == 0 or (self.curStruct and self._structs_brace_level[self.curStruct['type']]==self.braceDepth):
-                        trace_print( 'END OF STRUCT DEF' )
-                        self.curStruct = None
-
-                    if self._method_body and (self.braceDepth + 1) <= self._method_body:
-                        self._method_body = None; self.stack = []; self.nameStack = []; trace_print( 'FORCE CLEAR METHBODY' )
-                
-                if (tok.type == 'OPEN_PAREN'):
-                    self.nameStack.append(tok.value)
-                elif (tok.type == 'CLOSE_PAREN'):
-                    self.nameStack.append(tok.value)
-                elif (tok.type == 'OPEN_SQUARE_BRACKET'):
-                    self.nameStack.append(tok.value)
-                elif (tok.type == 'CLOSE_SQUARE_BRACKET'):
-                    self.nameStack.append(tok.value)
-                elif (tok.type == 'TAB'): pass
-                elif (tok.type == 'EQUALS'):
-                    self.nameStack.append(tok.value)
-                elif (tok.type == 'COMMA'):
-                    self.nameStack.append(tok.value)
-                elif (tok.type == 'BACKSLASH'):
-                    self.nameStack.append(tok.value)
-                elif (tok.type == 'PIPE'):
-                    self.nameStack.append(tok.value)
-                elif (tok.type == 'PERCENT'):
-                    self.nameStack.append(tok.value)
-                elif (tok.type == 'CARET'):
-                    self.nameStack.append(tok.value)
-                elif (tok.type == 'EXCLAMATION'):
-                    self.nameStack.append(tok.value)
-                elif (tok.type == 'SQUOTE'): pass
-                elif (tok.type == 'NUMBER'):
-                    self.nameStack.append(tok.value)
-                elif (tok.type == 'MINUS'):
-                    self.nameStack.append(tok.value)
-                elif (tok.type == 'PLUS'):
-                    self.nameStack.append(tok.value)
-                elif (tok.type == 'STRING_LITERAL'):
-                    self.nameStack.append(tok.value)
-                elif (tok.type == 'NAME' or tok.type == 'AMPERSTAND' or tok.type == 'ASTERISK' or tok.type == 'CHAR_LITERAL'):
-                    if tok.value in ignoreSymbols:
-                        debug_print("Ignore symbol %s"%tok.value)
-                    elif (tok.value == 'class'):
-                        self.nameStack.append(tok.value)
-                    elif tok.value in supportedAccessSpecifier:
-                        if len(self.nameStack) and self.nameStack[0] in ("class", "struct", "union"):
-                            self.nameStack.append(tok.value)
-                        elif self.braceDepth == len(self.nameSpaces) + 1 or self.braceDepth == (len(self.nameSpaces) + len(self.curClass.split("::"))):
-                            self.curAccessSpecifier = tok.value;
-                            self.accessSpecifierScratch.append(tok.value)
-                            debug_print("curAccessSpecifier updated to %s"%self.curAccessSpecifier)
-                        self.stack = []
-                    else:
-                        self.nameStack.append(tok.value)
-                        if self.anon_union_counter[0] == self.braceDepth:
-                            self.anon_union_counter = [-1, 0]
-                elif (tok.type == 'COLON'):
-                    #Dont want colon to be first in stack
-                    if len(self.nameStack) == 0:
-                        self.accessSpecifierScratch = []
-                        continue
-                    
-                    # Handle situation where access specifiers can be multi words such as "public slots"
-                    jns = " ".join(self.accessSpecifierScratch + self.nameStack)
-                    if jns in supportedAccessSpecifier:
-                        self.curAccessSpecifier = jns;
-                        debug_print("curAccessSpecifier updated to %s"%self.curAccessSpecifier)
-                        self.stack = []
-                        self.nameStack = []
-                    else:
-                        self.nameStack.append(tok.value)
-                    self.accessSpecifierScratch = []
-
-                elif (tok.type == 'SEMI_COLON'):
-                    if self.anon_union_counter[0] == self.braceDepth and self.anon_union_counter[1]:
-                        debug_print("Creating anonymous union")
-                        #Force the processing of an anonymous union
-                        saved_namestack = self.nameStack[:] 
-                        saved_stack = self.stack[:]
-                        self.nameStack = [""]
-                        self.stack = self.nameStack + [";"]
-                        self.nameStack = self.nameStack[0:1]
-                        debug_print("pre eval anon stack")
-                        self.evaluate_stack( tok.type )
-                        debug_print("post eval anon stack")
-                        self.nameStack = saved_namestack
-                        self.stack = saved_stack
-                        self.anon_union_counter = [-1, 0];
-                    
-                    
-                    if (self.braceDepth < 10): self.evaluate_stack( tok.type )
-                    if not self.stack: continue
-                    if self.stack[0]=='typedef' and ( '{' not in self.stack or '}' in self.stack ): self.stack = []; trace_print( "REAL CLEAR")
-                    elif self.stack[0] != 'typedef': self.stack = []; trace_print('CLEAR STACK')
-
-        except:
-            if (debug): raise
-            raise CppParseError("Not able to parse %s on line %d evaluating \"%s\"\nError around: %s"
-                                % (self.headerFileName, tok.lineno, tok.value, " ".join(self.nameStack)))
-
-        self.finalize()
-        global parseHistory
-        parseHistory = []
-
-    def evaluate_stack(self, token=None):
-        """Evaluates the current name stack"""
-        global doxygenCommentCache
-        debug_print( "Evaluating stack %s\n       BraceDepth: %s (called from %d)" %(self.nameStack,self.braceDepth, inspect.currentframe().f_back.f_lineno))
-        
-        #Handle special case of overloading operator ()
-        if "operator()(" in "".join(self.nameStack):
-            operator_index = self.nameStack.index("operator")
-            self.nameStack.pop(operator_index + 2)
-            self.nameStack.pop(operator_index + 1)
-            self.nameStack[operator_index] = "operator()"
-        
-        if (len(self.curClass)):
-            debug_print( "%s (%s) "%(self.curClass, self.curAccessSpecifier))
-
-        #Filter special case of array with casting in it
-        try:
-            bracePos = self.nameStack.index("[")
-            parenPos = self.nameStack.index("(")
-            if bracePos == parenPos - 1:
-                endParen = self.nameStack.index(")")
-                self.nameStack = self.nameStack[:bracePos + 1] + self.nameStack[endParen + 1:]
-                debug_print("Filtered namestack to=%s"%self.nameStack)
-        except: pass
-
-        #if 'typedef' in self.nameStack: self.evaluate_typedef()        # allows nested typedefs, probably a bad idea
-        if not self.curClass and 'typedef' in self.nameStack:
-            trace_print('STACK', self.stack)
-            if token == 'SEMI_COLON' and ('{' not in self.stack or '}' in self.stack): self.evaluate_typedef()
-            else: return
-        
-        elif (len(self.nameStack) == 0):
-            debug_print( "trace" )
-            debug_print( "(Empty Stack)" )
-            return
-        elif (self.nameStack[0] == "namespace"):
-            #Taken care of outside of here
-            pass
-        elif self.nameStack[0] == "friend":
-            pass
-        elif len(self.nameStack) >= 2 and self.nameStack[0] == 'using' and self.nameStack[1] == 'namespace': pass    # TODO
-
-        elif is_enum_namestack(self.nameStack):
-            debug_print( "trace" )
-            self.evaluate_enum_stack()
-
-        elif self._method_body and (self.braceDepth + 1) > self._method_body: trace_print( 'INSIDE METHOD DEF' )
-        elif is_method_namestack(self.stack) and not self.curStruct and '(' in self.nameStack:
-            debug_print( "trace" )
-            if self.braceDepth > 0:
-                if "{" in self.stack and self.stack[0] != '{' and self.stack[-1] == ';' and self.braceDepth == 1:
-                    #Special case of a method defined outside a class that has a body
-                    pass
-                else: 
-                    self.evaluate_method_stack()
-            else:
-                #Free function
-                self.evaluate_method_stack()
-        elif is_property_namestack(self.nameStack) and self.stack[-1] == ';':
-            debug_print( "trace" )
-            if self.nameStack[0] in ('class', 'struct') and len(self.stack) == 3: self.evalute_forward_decl()
-            elif len(self.nameStack) >= 2 and (self.nameStack[0]=='friend' and self.nameStack[1]=='class'): pass
-            else: self.evaluate_property_stack()    # catches class props and structs in a namespace
-
-        elif self.nameStack[0] in ("class", "struct", "union"):
-            #Parsing a union can reuse much of the class parsing
-            debug_print( "trace" )
-            self.evaluate_class_stack()
-        #elif (self.nameStack[0] == "struct"):
-        #    debug_print( "trace" )
-            ##this causes a bug when structs are nested in protected or private##self.curAccessSpecifier = "public"
-        #    self.evaluate_struct_stack()
-
-
-        elif not self.curClass:
-            debug_print( "trace" )
-            if is_enum_namestack(self.nameStack): self.evaluate_enum_stack()
-            elif self.curStruct and self.stack[-1] == ';': self.evaluate_property_stack()    # this catches fields of global structs
-            self.nameStack = []
-            doxygenCommentCache = ""
-            return
-        elif (self.braceDepth < 1):
-            debug_print( "trace" )
-            #Ignore global stuff for now
-            debug_print( "Global stuff: %s"%self.nameStack )
-            self.nameStack = []
-            doxygenCommentCache = ""
-            return
-        elif (self.braceDepth > len(self.nameSpaces) + 1):
-            debug_print( "trace" )
-            self.nameStack = []
-            doxygenCommentCache = ""
-            return
-
-        self.nameStack = []        # its a little confusing to have some if/else above return and others not, and then clearning the nameStack down here
-        doxygenCommentCache = ""
-    
-
-    def evaluate_enum_stack(self):
-        """Create an Enum out of the name stack"""
-        debug_print( "evaluating enum" )
-        newEnum = CppEnum(self.nameStack)
-        if len(list(newEnum.keys())):
-            if len(self.curClass):
-                newEnum["namespace"] = self.cur_namespace(False)
-                klass = self.classes[self.curClass]
-                klass["enums"][self.curAccessSpecifier].append(newEnum)
-                if self.curAccessSpecifier == 'public' and 'name' in newEnum: klass._public_enums[ newEnum['name'] ] = newEnum
-            else:
-                newEnum["namespace"] = self.cur_namespace(True)
-                self.enums.append(newEnum)
-                if 'name' in newEnum and newEnum['name']: self.global_enums[ newEnum['name'] ] = newEnum
-
-            #This enum has instances, turn them into properties
-            if "instances" in newEnum:
-                instanceType = "enum"
-                if "name" in newEnum:
-                    instanceType = newEnum["name"]
-                for instance in newEnum["instances"]:
-                    self.nameStack = [instanceType,  instance]
-                    self.evaluate_property_stack()
-                del newEnum["instances"]
-
-
-    def __repr__(self):
-        rtn = ""
-        for className in list(self.classes.keys()):
-            rtn += "%s\n"%self.classes[className]
-        if self.functions:
-            rtn += "// functions\n"
-            for f in self.functions:
-                rtn += "%s\n"%f
-        if self.enums:
-            rtn += "// enums\n"
-            for f in self.enums:
-                rtn += "%s\n"%f
-        return rtn

scripts/create_lua_library/LuaBindingsGenerator.py

@@ -0,0 +1,209 @@
+import ConfigParser
+import io
+import os
+import re
+
+class LuaBindingsGenerator(object):
+
+		def __init__(self, config):
+			self.config = config
+			self.wrappersHeaderList = ""
+			self.wrappersHeaderBody = ""
+			self.cppRegisterOut = ""
+			self.disableGC = self.config.get('lua', 'DisableGarbageCollection').replace(" ", "").split(",")
+			self.libName = self.config.get('global', 'LibraryName')
+
+		def processTargetFile(self, targetFile):
+			self.wrappersHeaderList += "#include \"%s/%s\"\n" % (self.config.get('global', 'HeaderIncludeDirectory'), targetFile)
+
+		def processClass(self, c):
+			for method in c["methods"]:
+				idx = 1
+				if method["name"] == c["name"]:
+					self.cppRegisterOut += "\t\t{\"%s\", %s_%s},\n" % (c["name"], self.libName, c["name"])
+					self.wrappersHeaderBody += "\tstatic int %s_%s(lua_State *L) {\n" % (self.libName, c["name"])
+				else:
+					self.cppRegisterOut += "\t\t{\"%s_%s\", %s_%s_%s},\n" % (c["name"], method["name"], self.libName, c["name"], method["name"])
+					self.wrappersHeaderBody += "\tstatic int %s_%s_%s(lua_State *L) {\n" % (self.libName, c["name"], method["name"])
+
+					# if this is not a static method, get the class pointer being passed
+					if method["type"].find("static ") == -1:
+						self.wrappersHeaderBody += "\t\tluaL_checktype(L, 1, LUA_TUSERDATA);\n"
+						self.wrappersHeaderBody += "\t\t%s *inst = (%s*) *((PolyBase**)lua_touserdata(L, 1));\n" % (c["name"], c["name"])
+						idx = 2
+
+				paramlist = []
+				lparamlist = []
+				for param in method["parameters"]:
+					luatype = "LUA_TUSERDATA"
+					checkfunc = "lua_isuserdata"
+					if param["type"].find("*") > -1:
+						luafunc = "(%s) *((PolyBase**)lua_touserdata" % (param["type"].replace("Polygon", "Polycode::Polygon").replace("Rectangle", "Polycode::Rectangle"))
+					elif param["type"].find("&") > -1:
+						luafunc = "*(%s*) *((PolyBase**)lua_touserdata" % (param["type"].replace("const", "").replace("&", "").replace("Polygon", "Polycode::Polygon").replace("Rectangle", "Polycode::Rectangle"))
+					else:
+						luafunc = "*(%s*) *((PolyBase**)lua_touserdata" % (param["type"].replace("Polygon", "Polycode::Polygon").replace("Rectangle", "Polycode::Rectangle"))
+					lend = ".__ptr"
+					luafuncsuffix = ")"
+					if param["type"] == "int" or param["type"] == "unsigned int" or param["type"] == "short":
+						luafunc = "lua_tointeger"
+						luatype = "LUA_TNUMBER"
+						checkfunc = "lua_isnumber"
+						luafuncsuffix = ""
+						lend = ""
+					if param["type"] == "PolyKEY":
+						luafunc = "(PolyKEY)lua_tointeger"
+						luatype = "LUA_TNUMBER"
+						checkfunc = "lua_isnumber"
+						luafuncsuffix = ""
+						lend = ""
+					if param["type"] == "bool":
+						luafunc = "lua_toboolean"
+						luatype = "LUA_TBOOLEAN"
+						checkfunc = "lua_isboolean"
+						luafuncsuffix = " != 0"
+						lend = ""
+					if param["type"] == "Number":
+						luatype = "LUA_TNUMBER"
+						luafunc = "lua_tonumber"
+						checkfunc = "lua_isnumber"
+						luafuncsuffix = ""
+						lend = ""
+					if param["type"] == "String":
+						luatype = "LUA_TSTRING"
+						luafunc = "lua_tostring"
+						checkfunc = "lua_isstring"
+						luafuncsuffix = ""
+						lend = ""
+					
+					param["type"] = param["type"].replace("Polygon", "Polycode::Polygon").replace("Rectangle", "Polycode::Rectangle")
+
+					if "defaltValue" in param:
+						if checkfunc != "lua_isuserdata" or (checkfunc == "lua_isuserdata" and param["defaltValue"] == "NULL"):
+							#param["defaltValue"] = param["defaltValue"].replace(" 0f", ".0f")
+							param["defaltValue"] = param["defaltValue"].replace(": :", "::")
+							#param["defaltValue"] = param["defaltValue"].replace("0 ", "0.")
+							param["defaltValue"] = re.sub(r'([0-9]+) ([0-9])+', r'\1.\2', param["defaltValue"])
+
+							self.wrappersHeaderBody += "\t\t%s %s;\n" % (param["type"], param["name"])
+							self.wrappersHeaderBody += "\t\tif(%s(L, %d)) {\n" % (checkfunc, idx)
+							self.wrappersHeaderBody += "\t\t\t%s = %s(L, %d)%s;\n" % (param["name"], luafunc, idx, luafuncsuffix)
+							self.wrappersHeaderBody += "\t\t} else {\n"
+							self.wrappersHeaderBody += "\t\t\t%s = %s;\n" % (param["name"], param["defaltValue"])
+							self.wrappersHeaderBody += "\t\t}\n"
+						else:
+							self.wrappersHeaderBody += "\t\tluaL_checktype(L, %d, %s);\n" % (idx, luatype);
+							if param["type"] == "String":
+								self.wrappersHeaderBody += "\t\t%s %s = String(%s(L, %d));\n" % (param["type"], param["name"], luafunc, idx)
+							else:
+								self.wrappersHeaderBody += "\t\t%s %s = %s(L, %d)%s;\n" % (param["type"], param["name"], luafunc, idx,luafuncsuffix)
+					else:
+						self.wrappersHeaderBody += "\t\tluaL_checktype(L, %d, %s);\n" % (idx, luatype);
+						if param["type"] == "String":
+							self.wrappersHeaderBody += "\t\t%s %s = String(%s(L, %d));\n" % (param["type"], param["name"], luafunc, idx)
+						else:
+							self.wrappersHeaderBody += "\t\t%s %s = %s(L, %d)%s;\n" % (param["type"], param["name"], luafunc, idx, luafuncsuffix)
+					paramlist.append(param["name"])
+					lparamlist.append(param["name"]+lend)
+					idx = idx +1 # Param parse success-- mark the increased stack
+
+				# Generate C++-side method call / generate return value
+				if method["name"] == c["name"]: # If constructor
+					if c["name"] == "EventHandler": # See LuaEventHandler above
+						self.wrappersHeaderBody += "\t\tLuaEventHandler *inst = new LuaEventHandler();\n"
+						self.wrappersHeaderBody += "\t\tinst->wrapperIndex = luaL_ref(L, LUA_REGISTRYINDEX );\n"
+						self.wrappersHeaderBody += "\t\tinst->L = L;\n"
+					else:
+						self.wrappersHeaderBody += "\t\t%s *inst = new %s(%s);\n" % (c["name"], c["name"], ", ".join(paramlist))
+					
+					self.wrappersHeaderBody += "\t\tPolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));\n"
+					self.wrappersHeaderBody += "\t\t*userdataPtr = (PolyBase*)inst;\n"
+					self.wrappersHeaderBody += "\t\tluaL_getmetatable(L, \"%s.%s\");\n" % (self.libName, c["name"])
+					self.wrappersHeaderBody += "\t\tlua_setmetatable(L, -2);\n"
+					self.wrappersHeaderBody += "\t\treturn 1;\n"
+				else: #If non-constructor
+					if method["type"].find("static ") == -1: # If non-static
+						call = "inst->%s(%s)" % (method["name"], ", ".join(paramlist))
+					else: # If static (FIXME: Why doesn't this work?)
+						call = "%s::%s(%s)" % (c["name"], method["name"], ", ".join(paramlist))
+
+					#check if returning a template
+					if method["type"].find("<") > -1:
+						#if returning a vector, convert to lua table
+						if method["type"].find("std::vector") > -1:
+							vectorReturnClass = method["type"].replace("std::vector<", "").replace(">","").replace(" ", "")
+							if vectorReturnClass.find("&") == -1 and vectorReturnClass.find("*") > -1: #FIXME: return references to std::vectors and basic types
+								vectorReturn = True
+								self.wrappersHeaderBody += "\t\tstd::vector<%s> retVector = %s;\n" % (vectorReturnClass,call)
+								self.wrappersHeaderBody += "\t\tlua_newtable(L);\n"
+								self.wrappersHeaderBody += "\t\tfor(int i=0; i < retVector.size(); i++) {\n"
+								self.wrappersHeaderBody += "\t\t\tPolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));\n"
+								self.wrappersHeaderBody += "\t\t\t*userdataPtr = (PolyBase*)retVector[i];\n"
+								self.wrappersHeaderBody += "\t\t\tlua_rawseti(L, -2, i+1);\n"
+								self.wrappersHeaderBody += "\t\t}\n"
+								self.wrappersHeaderBody += "\t\treturn 1;\n"
+							else:
+								self.wrappersHeaderBody += "\t\treturn 0;\n"
+								
+					# else If void-typed:
+					elif method["type"] == "void" or method["type"] == "static void" or method["type"] == "virtual void" or method["type"] == "inline void":
+						self.wrappersHeaderBody += "\t\t%s;\n" % (call)
+						basicType = True
+						voidRet = True
+						vectorReturn = False
+						self.wrappersHeaderBody += "\t\treturn 0;\n" # 0 arguments returned
+					else: # If there is a return value:
+						# What type is the return value? Default to pointer
+						outfunc = "this_shouldnt_happen"
+						retFunc = ""
+						basicType = False
+						vectorReturn = False
+						if method["type"] == "Number" or  method["type"] == "inline Number":
+							outfunc = "lua_pushnumber"
+							basicType = True
+						if method["type"] == "String" or method["type"] == "static String": # TODO: Path for STL strings?
+							outfunc = "lua_pushstring"
+							basicType = True
+							retFunc = ".c_str()"
+						if method["type"] == "int" or method["type"] == "unsigned int" or method["type"] == "static int" or  method["type"] == "size_t" or method["type"] == "static size_t" or method["type"] == "long" or method["type"] == "unsigned int" or method["type"] == "static long" or method["type"] == "short" or method["type"] == "PolyKEY" or method["type"] == "wchar_t":
+							outfunc = "lua_pushinteger"
+							basicType = True
+						if method["type"] == "bool" or method["type"] == "static bool" or method["type"] == "virtual bool":
+							outfunc = "lua_pushboolean"
+							basicType = True
+
+						if method["type"].find("*") > -1: # Returned var is definitely a pointer.
+							self.wrappersHeaderBody += "\t\tPolyBase *ptrRetVal = (PolyBase*)%s%s;\n" % (call, retFunc)
+							self.wrappersHeaderBody += "\t\tif(ptrRetVal == NULL) {\n"
+							self.wrappersHeaderBody += "\t\t\tlua_pushnil(L);\n"
+							self.wrappersHeaderBody += "\t\t} else {\n"
+							self.wrappersHeaderBody += "\t\t\tPolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));\n"
+							self.wrappersHeaderBody += "\t\t\t*userdataPtr = ptrRetVal;\n"
+							self.wrappersHeaderBody += "\t\t}\n"
+						elif basicType == True: # Returned var has been flagged as a recognized primitive type
+							self.wrappersHeaderBody += "\t\t%s(L, %s%s);\n" % (outfunc, call, retFunc)
+						else: # Some static object is being returned. Convert it to a pointer, then return that.
+							className = method["type"].replace("const", "").replace("&", "").replace("inline", "").replace("virtual", "").replace("static", "")
+							if className == "Polygon": # Deal with potential windows.h conflict
+								className = "Polycode::Polygon"
+							if className == "Rectangle":
+								className = "Polycode::Rectangle"
+							if className == "Polycode : : Rectangle":
+								className = "Polycode::Rectangle"
+							self.wrappersHeaderBody += "\t\t%s *retInst = new %s();\n" % (className, className)
+							self.wrappersHeaderBody += "\t\t*retInst = %s;\n" % (call)
+							self.wrappersHeaderBody += "\t\tPolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));\n"
+							self.wrappersHeaderBody += "\t\tluaL_getmetatable(L, \"%s.%s\");\n" % (self.libName, className)
+							self.wrappersHeaderBody += "\t\tlua_setmetatable(L, -2);\n"
+							self.wrappersHeaderBody += "\t\t*userdataPtr = (PolyBase*)retInst;\n"
+						self.wrappersHeaderBody += "\t\treturn 1;\n"
+
+				self.wrappersHeaderBody += "\t}\n"
+
+		def finalize(self):
+			with open(self.config.get('lua', 'WrapperHeaderTemplate'), 'r') as f:
+				out = f.read().replace("%HEADERS%", self.wrappersHeaderList)
+				out = out.replace("%BODY%", self.wrappersHeaderBody)
+				fout = open(self.config.get('lua', 'WrapperHeaderTarget'), "w")
+				fout.write(out)
+				fout.close()

scripts/create_lua_library/PolycodeLuaWrappers.h

@@ -0,0 +1,12641 @@
+#pragma once
+
+extern "C" {
+	#include <stdio.h>
+	#include "lua.h"
+	#include "lualib.h"
+	#include "lauxlib.h"
+} 
+
+#include "polycode/core/PolyBasicFileProvider.h"
+#include "polycode/core/PolyBezierCurve.h"
+#include "polycode/core/PolyBone.h"
+#include "polycode/core/PolyCamera.h"
+#include "polycode/core/PolyColor.h"
+#include "polycode/core/PolyConfig.h"
+#include "polycode/core/PolyCore.h"
+#include "polycode/core/PolyCoreFileProvider.h"
+#include "polycode/core/PolyCoreInput.h"
+#include "polycode/core/PolyCoreServices.h"
+#include "polycode/core/PolyCubemap.h"
+#include "polycode/core/PolyData.h"
+#include "polycode/core/PolyEntity.h"
+#include "polycode/core/PolyEvent.h"
+#include "polycode/core/PolyEventDispatcher.h"
+#include "polycode/core/PolyEventHandler.h"
+#include "polycode/core/PolyFont.h"
+#include "polycode/core/PolyGlobals.h"
+#include "polycode/core/PolyGPUDrawBuffer.h"
+#include "polycode/core/PolyImage.h"
+#include "polycode/core/PolyInputEvent.h"
+#include "polycode/core/PolyInputKeys.h"
+#include "polycode/core/PolyLabel.h"
+#include "polycode/core/PolyMaterial.h"
+#include "polycode/core/PolyMaterialManager.h"
+#include "polycode/core/PolyMatrix4.h"
+#include "polycode/core/PolyMesh.h"
+#include "polycode/core/PolyObject.h"
+#include "polycode/core/PolyOpenGLGraphicsInterface.h"
+#include "polycode/core/PolyPAAudioInterface.h"
+#include "polycode/core/PolyParticleEmitter.h"
+#include "polycode/core/PolyPerlin.h"
+#include "polycode/core/PolyPhysFSFileProvider.h"
+#include "polycode/core/PolyQuaternion.h"
+#include "polycode/core/PolyQuaternionCurve.h"
+#include "polycode/core/PolyRay.h"
+#include "polycode/core/PolyRectangle.h"
+#include "polycode/core/PolyRenderDataArray.h"
+#include "polycode/core/PolyRenderer.h"
+#include "polycode/core/PolyResource.h"
+#include "polycode/core/PolyResourceManager.h"
+#include "polycode/core/PolyScene.h"
+#include "polycode/core/PolySceneEntityInstance.h"
+#include "polycode/core/PolySceneImage.h"
+#include "polycode/core/PolySceneLabel.h"
+#include "polycode/core/PolySceneLight.h"
+#include "polycode/core/PolySceneLine.h"
+#include "polycode/core/PolySceneManager.h"
+#include "polycode/core/PolySceneMesh.h"
+#include "polycode/core/PolyScenePrimitive.h"
+#include "polycode/core/PolySceneRenderTexture.h"
+#include "polycode/core/PolySceneSound.h"
+#include "polycode/core/PolySceneSprite.h"
+#include "polycode/core/PolyScript.h"
+#include "polycode/core/PolyShader.h"
+#include "polycode/core/PolySkeleton.h"
+#include "polycode/core/PolySound.h"
+#include "polycode/core/PolySoundManager.h"
+#include "polycode/core/PolyString.h"
+#include "polycode/core/PolyTexture.h"
+#include "polycode/core/PolyTimer.h"
+#include "polycode/core/PolyTimerManager.h"
+#include "polycode/core/PolyVector2.h"
+#include "polycode/core/PolyVector3.h"
+#include "polycode/core/PolyVector4.h"
+
+
+using namespace std;
+namespace Polycode {
+
+	class LuaEventHandler : public EventHandler {
+	public:
+		LuaEventHandler() : EventHandler() {}
+		void handleEvent(Event *e) {
+			lua_getglobal(L, "__customError");
+			int errH = lua_gettop(L);
+			lua_getglobal(L, "__handleEvent");
+			lua_rawgeti( L, LUA_REGISTRYINDEX, wrapperIndex );
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = (PolyBase*)e;
+			lua_pcall(L, 2, 0, errH);
+			lua_settop(L, 0);
+		}
+		int wrapperIndex;
+		lua_State *L;
+	};
+
+	static int Polycode_BasicFile_read(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BasicFile *inst = (BasicFile*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		void* ptr = (void*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		size_t size = *(size_t*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		size_t count = *(size_t*) *((PolyBase**)lua_touserdata(L, 4));
+		lua_pushinteger(L, inst->read(ptr, size, count));
+		return 1;
+	}
+	static int Polycode_BasicFile_write(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BasicFile *inst = (BasicFile*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		void* ptr = (void*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		size_t size = *(size_t*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		size_t count = *(size_t*) *((PolyBase**)lua_touserdata(L, 4));
+		lua_pushinteger(L, inst->write(ptr, size, count));
+		return 1;
+	}
+	static int Polycode_BasicFile_seek(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BasicFile *inst = (BasicFile*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int offset = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int origin = lua_tointeger(L, 3);
+		lua_pushinteger(L, inst->seek(offset, origin));
+		return 1;
+	}
+	static int Polycode_BasicFile_tell(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BasicFile *inst = (BasicFile*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->tell());
+		return 1;
+	}
+	static int Polycode_BasicFileProvider(lua_State *L) {
+		BasicFileProvider *inst = new BasicFileProvider();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.BasicFileProvider");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_BasicFileProvider_openFile(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BasicFileProvider *inst = (BasicFileProvider*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String opts = String(lua_tostring(L, 3));
+		PolyBase *ptrRetVal = (PolyBase*)inst->openFile(fileName, opts);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_BasicFileProvider_closeFile(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BasicFileProvider *inst = (BasicFileProvider*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		CoreFile* file = (CoreFile*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->closeFile(file);
+		return 0;
+	}
+	static int Polycode_BasicFileProvider_addSource(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BasicFileProvider *inst = (BasicFileProvider*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String source = String(lua_tostring(L, 2));
+		inst->addSource(source);
+		return 0;
+	}
+	static int Polycode_BasicFileProvider_removeSource(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BasicFileProvider *inst = (BasicFileProvider*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String source = String(lua_tostring(L, 2));
+		inst->removeSource(source);
+		return 0;
+	}
+	static int Polycode_BezierCurve(lua_State *L) {
+		BezierCurve *inst = new BezierCurve();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.BezierCurve");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_BezierCurve_getControlPoint(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BezierCurve *inst = (BezierCurve*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->getControlPoint(index);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_BezierCurve_getNumControlPoints(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BezierCurve *inst = (BezierCurve*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getNumControlPoints());
+		return 1;
+	}
+	static int Polycode_BezierCurve_addControlPoint(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BezierCurve *inst = (BezierCurve*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number p1x = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number p1y = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number p1z = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number p2x = lua_tonumber(L, 5);
+		luaL_checktype(L, 6, LUA_TNUMBER);
+		Number p2y = lua_tonumber(L, 6);
+		luaL_checktype(L, 7, LUA_TNUMBER);
+		Number p2z = lua_tonumber(L, 7);
+		luaL_checktype(L, 8, LUA_TNUMBER);
+		Number p3x = lua_tonumber(L, 8);
+		luaL_checktype(L, 9, LUA_TNUMBER);
+		Number p3y = lua_tonumber(L, 9);
+		luaL_checktype(L, 10, LUA_TNUMBER);
+		Number p3z = lua_tonumber(L, 10);
+		inst->addControlPoint(p1x, p1y, p1z, p2x, p2y, p2z, p3x, p3y, p3z);
+		return 0;
+	}
+	static int Polycode_BezierCurve_addControlPoint3dWithHandles(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BezierCurve *inst = (BezierCurve*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number p1x = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number p1y = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number p1z = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number p2x = lua_tonumber(L, 5);
+		luaL_checktype(L, 6, LUA_TNUMBER);
+		Number p2y = lua_tonumber(L, 6);
+		luaL_checktype(L, 7, LUA_TNUMBER);
+		Number p2z = lua_tonumber(L, 7);
+		luaL_checktype(L, 8, LUA_TNUMBER);
+		Number p3x = lua_tonumber(L, 8);
+		luaL_checktype(L, 9, LUA_TNUMBER);
+		Number p3y = lua_tonumber(L, 9);
+		luaL_checktype(L, 10, LUA_TNUMBER);
+		Number p3z = lua_tonumber(L, 10);
+		inst->addControlPoint3dWithHandles(p1x, p1y, p1z, p2x, p2y, p2z, p3x, p3y, p3z);
+		return 0;
+	}
+	static int Polycode_BezierCurve_addControlPoint3d(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BezierCurve *inst = (BezierCurve*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number z = lua_tonumber(L, 4);
+		inst->addControlPoint3d(x, y, z);
+		return 0;
+	}
+	static int Polycode_BezierCurve_addControlPoint2dWithHandles(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BezierCurve *inst = (BezierCurve*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number p1x = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number p1y = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number p2x = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number p2y = lua_tonumber(L, 5);
+		luaL_checktype(L, 6, LUA_TNUMBER);
+		Number p3x = lua_tonumber(L, 6);
+		luaL_checktype(L, 7, LUA_TNUMBER);
+		Number p3y = lua_tonumber(L, 7);
+		inst->addControlPoint2dWithHandles(p1x, p1y, p2x, p2y, p3x, p3y);
+		return 0;
+	}
+	static int Polycode_BezierCurve_addControlPoint2d(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BezierCurve *inst = (BezierCurve*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 3);
+		inst->addControlPoint2d(x, y);
+		return 0;
+	}
+	static int Polycode_BezierCurve_getPointAt(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BezierCurve *inst = (BezierCurve*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number a = lua_tonumber(L, 2);
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->getPointAt(a);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_BezierCurve_getPointBetween(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BezierCurve *inst = (BezierCurve*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number a = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		BezierPoint* bp1 = (BezierPoint*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		BezierPoint* bp2 = (BezierPoint*) *((PolyBase**)lua_touserdata(L, 4));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->getPointBetween(a, bp1, bp2);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_BezierCurve_clearControlPoints(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BezierCurve *inst = (BezierCurve*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->clearControlPoints();
+		return 0;
+	}
+	static int Polycode_BezierCurve_getYValueAtX(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BezierCurve *inst = (BezierCurve*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 2);
+		lua_pushnumber(L, inst->getYValueAtX(x));
+		return 1;
+	}
+	static int Polycode_BezierCurve_getTValueAtX(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BezierCurve *inst = (BezierCurve*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 2);
+		lua_pushnumber(L, inst->getTValueAtX(x));
+		return 1;
+	}
+	static int Polycode_BezierCurve_removePoint(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BezierCurve *inst = (BezierCurve*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		BezierPoint* point = (BezierPoint*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->removePoint(point);
+		return 0;
+	}
+	static int Polycode_BezierCurve_setHeightCacheResolution(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BezierCurve *inst = (BezierCurve*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number resolution = lua_tonumber(L, 2);
+		inst->setHeightCacheResolution(resolution);
+		return 0;
+	}
+	static int Polycode_BezierCurve_rebuildHeightCache(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BezierCurve *inst = (BezierCurve*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->rebuildHeightCache();
+		return 0;
+	}
+	static int Polycode_BezierCurve_recalculateDistances(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BezierCurve *inst = (BezierCurve*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->recalculateDistances();
+		return 0;
+	}
+	static int Polycode_BezierPoint(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TNUMBER);
+		Number p1x = lua_tonumber(L, 1);
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number p1y = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number p1z = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number p2x = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number p2y = lua_tonumber(L, 5);
+		luaL_checktype(L, 6, LUA_TNUMBER);
+		Number p2z = lua_tonumber(L, 6);
+		luaL_checktype(L, 7, LUA_TNUMBER);
+		Number p3x = lua_tonumber(L, 7);
+		luaL_checktype(L, 8, LUA_TNUMBER);
+		Number p3y = lua_tonumber(L, 8);
+		luaL_checktype(L, 9, LUA_TNUMBER);
+		Number p3z = lua_tonumber(L, 9);
+		BezierPoint *inst = new BezierPoint(p1x, p1y, p1z, p2x, p2y, p2z, p3x, p3y, p3z);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.BezierPoint");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Bone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TSTRING);
+		String boneName = String(lua_tostring(L, 1));
+		Bone *inst = new Bone(boneName);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.Bone");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Bone_getName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Bone *inst = (Bone*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushstring(L, inst->getName().c_str());
+		return 1;
+	}
+	static int Polycode_Bone_setParentBone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Bone *inst = (Bone*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Bone* bone = (Bone*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setParentBone(bone);
+		return 0;
+	}
+	static int Polycode_Bone_addChildBone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Bone *inst = (Bone*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Bone* bone = (Bone*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->addChildBone(bone);
+		return 0;
+	}
+	static int Polycode_Bone_getParentBone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Bone *inst = (Bone*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getParentBone();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Bone_getNumChildBones(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Bone *inst = (Bone*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getNumChildBones());
+		return 1;
+	}
+	static int Polycode_Bone_getChildBone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Bone *inst = (Bone*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->getChildBone(index);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Bone_getBoneMatrix(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Bone *inst = (Bone*) *((PolyBase**)lua_touserdata(L, 1));
+		Matrix4 *retInst = new Matrix4();
+		*retInst = inst->getBoneMatrix();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Matrix4");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Bone_setBoneMatrix(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Bone *inst = (Bone*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Matrix4 matrix = *(Matrix4*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setBoneMatrix(matrix);
+		return 0;
+	}
+	static int Polycode_Bone_getRestMatrix(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Bone *inst = (Bone*) *((PolyBase**)lua_touserdata(L, 1));
+		Matrix4 *retInst = new Matrix4();
+		*retInst = inst->getRestMatrix();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Matrix4");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Bone_getFullRestMatrix(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Bone *inst = (Bone*) *((PolyBase**)lua_touserdata(L, 1));
+		Matrix4 *retInst = new Matrix4();
+		*retInst = inst->getFullRestMatrix();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Matrix4");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Bone_getParentRestMatrix(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Bone *inst = (Bone*) *((PolyBase**)lua_touserdata(L, 1));
+		Matrix4 *retInst = new Matrix4();
+		*retInst = inst->getParentRestMatrix();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Matrix4");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Bone_getFinalMatrix(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Bone *inst = (Bone*) *((PolyBase**)lua_touserdata(L, 1));
+		Matrix4 *retInst = new Matrix4();
+		*retInst = inst->getFinalMatrix();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Matrix4");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Bone_setRestMatrix(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Bone *inst = (Bone*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Matrix4 matrix = *(Matrix4*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setRestMatrix(matrix);
+		return 0;
+	}
+	static int Polycode_Bone_setBaseMatrix(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Bone *inst = (Bone*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Matrix4 matrix = *(Matrix4*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setBaseMatrix(matrix);
+		return 0;
+	}
+	static int Polycode_Bone_getBaseMatrix(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Bone *inst = (Bone*) *((PolyBase**)lua_touserdata(L, 1));
+		Matrix4 *retInst = new Matrix4();
+		*retInst = inst->getBaseMatrix();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Matrix4");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Bone_getFullBaseMatrix(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Bone *inst = (Bone*) *((PolyBase**)lua_touserdata(L, 1));
+		Matrix4 *retInst = new Matrix4();
+		*retInst = inst->getFullBaseMatrix();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Matrix4");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Bone_rebuildFinalMatrix(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Bone *inst = (Bone*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->rebuildFinalMatrix();
+		return 0;
+	}
+	static int Polycode_Bone_buildFinalMatrix(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Bone *inst = (Bone*) *((PolyBase**)lua_touserdata(L, 1));
+		Matrix4 *retInst = new Matrix4();
+		*retInst = inst->buildFinalMatrix();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Matrix4");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Bone_intializeBone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Bone *inst = (Bone*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 basePosition = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Vector3 baseScale = *(Vector3*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		Quaternion baseRotation = *(Quaternion*) *((PolyBase**)lua_touserdata(L, 4));
+		luaL_checktype(L, 5, LUA_TUSERDATA);
+		Vector3 restPosition = *(Vector3*) *((PolyBase**)lua_touserdata(L, 5));
+		luaL_checktype(L, 6, LUA_TUSERDATA);
+		Vector3 restScale = *(Vector3*) *((PolyBase**)lua_touserdata(L, 6));
+		luaL_checktype(L, 7, LUA_TUSERDATA);
+		Quaternion restRotation = *(Quaternion*) *((PolyBase**)lua_touserdata(L, 7));
+		inst->intializeBone(basePosition, baseScale, baseRotation, restPosition, restScale, restRotation);
+		return 0;
+	}
+	static int Polycode_Camera(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Scene* parentScene = (Scene*) *((PolyBase**)lua_touserdata(L, 1));
+		Camera *inst = new Camera(parentScene);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.Camera");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Camera_buildFrustumPlanes(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->buildFrustumPlanes();
+		return 0;
+	}
+	static int Polycode_Camera_isSphereInFrustum(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 pos = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number fRadius = lua_tonumber(L, 3);
+		lua_pushboolean(L, inst->isSphereInFrustum(pos, fRadius));
+		return 1;
+	}
+	static int Polycode_Camera_isAABBInFrustum(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		AABB aabb = *(AABB*) *((PolyBase**)lua_touserdata(L, 2));
+		lua_pushboolean(L, inst->isAABBInFrustum(aabb));
+		return 1;
+	}
+	static int Polycode_Camera_setOrthoMode(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool mode = lua_toboolean(L, 2) != 0;
+		inst->setOrthoMode(mode);
+		return 0;
+	}
+	static int Polycode_Camera_setOrthoSize(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number orthoSizeX = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number orthoSizeY = lua_tonumber(L, 3);
+		inst->setOrthoSize(orthoSizeX, orthoSizeY);
+		return 0;
+	}
+	static int Polycode_Camera_setFrustumMode(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number left = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number right = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number bottom = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number top = lua_tonumber(L, 5);
+		luaL_checktype(L, 6, LUA_TNUMBER);
+		Number front = lua_tonumber(L, 6);
+		luaL_checktype(L, 7, LUA_TNUMBER);
+		Number back = lua_tonumber(L, 7);
+		inst->setFrustumMode(left, right, bottom, top, front, back);
+		return 0;
+	}
+	static int Polycode_Camera_getOrthoMode(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->getOrthoMode());
+		return 1;
+	}
+	static int Polycode_Camera_getOrthoSizeX(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getOrthoSizeX());
+		return 1;
+	}
+	static int Polycode_Camera_getOrthoSizeY(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getOrthoSizeY());
+		return 1;
+	}
+	static int Polycode_Camera_setFOV(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number fov = lua_tonumber(L, 2);
+		inst->setFOV(fov);
+		return 0;
+	}
+	static int Polycode_Camera_getFOV(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getFOV());
+		return 1;
+	}
+	static int Polycode_Camera_setClippingPlanes(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number nearClipPlane = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number farClipPlane = lua_tonumber(L, 3);
+		inst->setClippingPlanes(nearClipPlane, farClipPlane);
+		return 0;
+	}
+	static int Polycode_Camera_getNearClippingPlane(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getNearClippingPlane());
+		return 1;
+	}
+	static int Polycode_Camera_getFarClippingPlane(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getFarClippingPlane());
+		return 1;
+	}
+	static int Polycode_Camera_setParentScene(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Scene* parentScene = (Scene*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setParentScene(parentScene);
+		return 0;
+	}
+	static int Polycode_Camera_getParentScene(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getParentScene();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Camera_createProjectionMatrix(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		Matrix4 *retInst = new Matrix4();
+		*retInst = inst->createProjectionMatrix();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Matrix4");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Camera_hasFilterShader(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->hasFilterShader());
+		return 1;
+	}
+	static int Polycode_Camera_drawFilter(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		RenderBuffer* targetBuffer = (RenderBuffer*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->drawFilter(targetBuffer);
+		return 0;
+	}
+	static int Polycode_Camera_setPostFilter(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Material* material = (Material*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setPostFilter(material);
+		return 0;
+	}
+	static int Polycode_Camera_setPostFilterByName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String shaderName = String(lua_tostring(L, 2));
+		inst->setPostFilterByName(shaderName);
+		return 0;
+	}
+	static int Polycode_Camera_removePostFilter(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->removePostFilter();
+		return 0;
+	}
+	static int Polycode_Camera_getScreenShaderMaterial(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getScreenShaderMaterial();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Camera_Clone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool deepClone = lua_toboolean(L, 2) != 0;
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool ignoreEditorOnly = lua_toboolean(L, 3) != 0;
+		PolyBase *ptrRetVal = (PolyBase*)inst->Clone(deepClone, ignoreEditorOnly);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Camera_applyClone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Entity* clone = (Entity*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool deepClone = lua_toboolean(L, 3) != 0;
+		luaL_checktype(L, 4, LUA_TBOOLEAN);
+		bool ignoreEditorOnly = lua_toboolean(L, 4) != 0;
+		inst->applyClone(clone, deepClone, ignoreEditorOnly);
+		return 0;
+	}
+	static int Polycode_Camera_getProjectionMatrix(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		Matrix4 *retInst = new Matrix4();
+		*retInst = inst->getProjectionMatrix();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Matrix4");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Camera_setCustomProjectionMatrix(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Matrix4 matrix = *(Matrix4*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setCustomProjectionMatrix(matrix);
+		return 0;
+	}
+	static int Polycode_Camera_getViewport(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		Polycode::Rectangle *retInst = new Polycode::Rectangle();
+		*retInst = inst->getViewport();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Polycode::Rectangle");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Camera_setViewport(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Polycode::Rectangle viewport = *(Polycode::Rectangle*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setViewport(viewport);
+		return 0;
+	}
+	static int Polycode_Camera_setOrthoSizeMode(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int orthoSizeMode = lua_tointeger(L, 2);
+		inst->setOrthoSizeMode(orthoSizeMode);
+		return 0;
+	}
+	static int Polycode_Camera_getOrthoSizeMode(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getOrthoSizeMode());
+		return 1;
+	}
+	static int Polycode_Camera_setProjectionMode(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int mode = lua_tointeger(L, 2);
+		inst->setProjectionMode(mode);
+		return 0;
+	}
+	static int Polycode_Camera_getProjectionMode(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getProjectionMode());
+		return 1;
+	}
+	static int Polycode_Camera_projectRayFrom2DCoordinate(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector2 coordinate = *(Vector2*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Polycode::Rectangle viewport = *(Polycode::Rectangle*) *((PolyBase**)lua_touserdata(L, 3));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->projectRayFrom2DCoordinate(coordinate, viewport);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Camera_renderFullScreenQuad(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		GPUDrawBuffer* drawBuffer = (GPUDrawBuffer*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int shaderPass = lua_tointeger(L, 3);
+		inst->renderFullScreenQuad(drawBuffer, shaderPass);
+		return 0;
+	}
+	static int Polycode_Camera_getShaderPass(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		ShaderPass *retInst = new ShaderPass();
+		*retInst = inst->getShaderPass(index);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.ShaderPass");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Camera_getNumShaderPasses(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Camera *inst = (Camera*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getNumShaderPasses());
+		return 1;
+	}
+	static int Polycode_Color(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TNUMBER);
+		Number r = lua_tonumber(L, 1);
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number g = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number b = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number a = lua_tonumber(L, 4);
+		Color *inst = new Color(r, g, b, a);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.Color");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Color_ColorWithInts(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Color *inst = (Color*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int r = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int g = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int b = lua_tointeger(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		int a = lua_tointeger(L, 5);
+		Color *retInst = new Color();
+		*retInst = inst->ColorWithInts(r, g, b, a);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Color");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Color_ColorWithHex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Color *inst = (Color*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int hex = lua_tointeger(L, 2);
+		Color *retInst = new Color();
+		*retInst = inst->ColorWithHex(hex);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Color");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Color_setColorHex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Color *inst = (Color*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int hex = lua_tointeger(L, 2);
+		inst->setColorHex(hex);
+		return 0;
+	}
+	static int Polycode_Color_setColorHexRGB(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Color *inst = (Color*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int hex = lua_tointeger(L, 2);
+		inst->setColorHexRGB(hex);
+		return 0;
+	}
+	static int Polycode_Color_setColorHexFromString(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Color *inst = (Color*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String hex = String(lua_tostring(L, 2));
+		inst->setColorHexFromString(hex);
+		return 0;
+	}
+	static int Polycode_Color_setColorHexRGBFromString(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Color *inst = (Color*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String hex = String(lua_tostring(L, 2));
+		inst->setColorHexRGBFromString(hex);
+		return 0;
+	}
+	static int Polycode_Color_setColorHSV(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Color *inst = (Color*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number h = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number s = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number v = lua_tonumber(L, 4);
+		inst->setColorHSV(h, s, v);
+		return 0;
+	}
+	static int Polycode_Color_setColorRGBA(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Color *inst = (Color*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int r = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int g = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int b = lua_tointeger(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		int a = lua_tointeger(L, 5);
+		inst->setColorRGBA(r, g, b, a);
+		return 0;
+	}
+	static int Polycode_Color_setColorRGB(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Color *inst = (Color*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int r = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int g = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int b = lua_tointeger(L, 4);
+		inst->setColorRGB(r, g, b);
+		return 0;
+	}
+	static int Polycode_Color_setColor(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Color *inst = (Color*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number r = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number g = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number b = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number a = lua_tonumber(L, 5);
+		inst->setColor(r, g, b, a);
+		return 0;
+	}
+	static int Polycode_Color_blendColor(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Color *inst = (Color*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Color c2 = *(Color*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int mode = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number amount = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TUSERDATA);
+		Color c3 = *(Color*) *((PolyBase**)lua_touserdata(L, 5));
+		Color *retInst = new Color();
+		*retInst = inst->blendColor(c2, mode, amount, c3);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Color");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Color_Random(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Color *inst = (Color*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->Random();
+		return 0;
+	}
+	static int Polycode_Color_getBrightness(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Color *inst = (Color*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getBrightness());
+		return 1;
+	}
+	static int Polycode_Color_RGBtoHSV(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Color *inst = (Color*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number r = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number g = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number b = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number h = lua_tonumber(L, 5);
+		luaL_checktype(L, 6, LUA_TNUMBER);
+		Number s = lua_tonumber(L, 6);
+		luaL_checktype(L, 7, LUA_TNUMBER);
+		Number v = lua_tonumber(L, 7);
+		inst->RGBtoHSV(r, g, b, h, s, v);
+		return 0;
+	}
+	static int Polycode_Color_getHue(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Color *inst = (Color*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getHue());
+		return 1;
+	}
+	static int Polycode_Color_getSaturation(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Color *inst = (Color*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getSaturation());
+		return 1;
+	}
+	static int Polycode_Color_getValue(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Color *inst = (Color*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getValue());
+		return 1;
+	}
+	static int Polycode_Color_getUint(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Color *inst = (Color*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getUint());
+		return 1;
+	}
+	static int Polycode_Config(lua_State *L) {
+		Config *inst = new Config();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.Config");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Config_loadConfig(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Config *inst = (Config*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String configNamespace = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 3));
+		inst->loadConfig(configNamespace, fileName);
+		return 0;
+	}
+	static int Polycode_Config_saveConfig(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Config *inst = (Config*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String configNamespace = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 3));
+		inst->saveConfig(configNamespace, fileName);
+		return 0;
+	}
+	static int Polycode_Config_getEntry(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Config *inst = (Config*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String configNamespace = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String key = String(lua_tostring(L, 3));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getEntry(configNamespace, key);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Config_setStringValue(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Config *inst = (Config*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String configNamespace = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String key = String(lua_tostring(L, 3));
+		luaL_checktype(L, 4, LUA_TSTRING);
+		String value = String(lua_tostring(L, 4));
+		inst->setStringValue(configNamespace, key, value);
+		return 0;
+	}
+	static int Polycode_Config_setNumericValue(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Config *inst = (Config*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String configNamespace = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String key = String(lua_tostring(L, 3));
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number value = lua_tonumber(L, 4);
+		inst->setNumericValue(configNamespace, key, value);
+		return 0;
+	}
+	static int Polycode_Config_getNumericValue(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Config *inst = (Config*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String configNamespace = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String key = String(lua_tostring(L, 3));
+		lua_pushnumber(L, inst->getNumericValue(configNamespace, key));
+		return 1;
+	}
+	static int Polycode_Config_getStringValue(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Config *inst = (Config*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String configNamespace = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String key = String(lua_tostring(L, 3));
+		lua_pushstring(L, inst->getStringValue(configNamespace, key).c_str());
+		return 1;
+	}
+	static int Polycode_Config_setBoolValue(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Config *inst = (Config*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String configNamespace = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String key = String(lua_tostring(L, 3));
+		luaL_checktype(L, 4, LUA_TBOOLEAN);
+		bool value = lua_toboolean(L, 4) != 0;
+		inst->setBoolValue(configNamespace, key, value);
+		return 0;
+	}
+	static int Polycode_Config_getBoolValue(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Config *inst = (Config*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String configNamespace = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String key = String(lua_tostring(L, 3));
+		lua_pushboolean(L, inst->getBoolValue(configNamespace, key));
+		return 1;
+	}
+	static int Polycode_Core_Update(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->Update());
+		return 1;
+	}
+	static int Polycode_Core_Render(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->Render();
+		return 0;
+	}
+	static int Polycode_Core_fixedUpdate(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->fixedUpdate());
+		return 1;
+	}
+	static int Polycode_Core_systemUpdate(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->systemUpdate());
+		return 1;
+	}
+	static int Polycode_Core_updateAndRender(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->updateAndRender());
+		return 1;
+	}
+	static int Polycode_Core_enableMouse(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool newval = lua_toboolean(L, 2) != 0;
+		inst->enableMouse(newval);
+		return 0;
+	}
+	static int Polycode_Core_captureMouse(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool newval = lua_toboolean(L, 2) != 0;
+		inst->captureMouse(newval);
+		return 0;
+	}
+	static int Polycode_Core_setCursor(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int cursorType = lua_tointeger(L, 2);
+		inst->setCursor(cursorType);
+		return 0;
+	}
+	static int Polycode_Core_warpCursor(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int x = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int y = lua_tointeger(L, 3);
+		inst->warpCursor(x, y);
+		return 0;
+	}
+	static int Polycode_Core_createThread(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Threaded* target = (Threaded*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->createThread(target);
+		return 0;
+	}
+	static int Polycode_Core_lockMutex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		CoreMutex* mutex = (CoreMutex*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->lockMutex(mutex);
+		return 0;
+	}
+	static int Polycode_Core_unlockMutex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		CoreMutex* mutex = (CoreMutex*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->unlockMutex(mutex);
+		return 0;
+	}
+	static int Polycode_Core_createMutex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->createMutex();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Core_copyStringToClipboard(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String str = String(lua_tostring(L, 2));
+		inst->copyStringToClipboard(str);
+		return 0;
+	}
+	static int Polycode_Core_getClipboardString(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushstring(L, inst->getClipboardString().c_str());
+		return 1;
+	}
+	static int Polycode_Core_getServices(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getServices();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Core_getFPS(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getFPS());
+		return 1;
+	}
+	static int Polycode_Core_Shutdown(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->Shutdown();
+		return 0;
+	}
+	static int Polycode_Core_isFullscreen(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->isFullscreen());
+		return 1;
+	}
+	static int Polycode_Core_getAALevel(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getAALevel());
+		return 1;
+	}
+	static int Polycode_Core_getInput(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getInput();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Core_getXRes(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getXRes());
+		return 1;
+	}
+	static int Polycode_Core_getYRes(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getYRes());
+		return 1;
+	}
+	static int Polycode_Core_getBackingXRes(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getBackingXRes());
+		return 1;
+	}
+	static int Polycode_Core_getBackingYRes(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getBackingYRes());
+		return 1;
+	}
+	static int Polycode_Core_getScreenInfo(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		int* width = (int*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		int* height = (int*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		int* hz = (int*) *((PolyBase**)lua_touserdata(L, 4));
+		inst->getScreenInfo(width, height, hz);
+		return 0;
+	}
+	static int Polycode_Core_getScreenWidth(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getScreenWidth());
+		return 1;
+	}
+	static int Polycode_Core_getScreenHeight(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getScreenHeight());
+		return 1;
+	}
+	static int Polycode_Core_createFolder(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String folderPath = String(lua_tostring(L, 2));
+		inst->createFolder(folderPath);
+		return 0;
+	}
+	static int Polycode_Core_copyDiskItem(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String itemPath = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String destItemPath = String(lua_tostring(L, 3));
+		inst->copyDiskItem(itemPath, destItemPath);
+		return 0;
+	}
+	static int Polycode_Core_moveDiskItem(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String itemPath = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String destItemPath = String(lua_tostring(L, 3));
+		inst->moveDiskItem(itemPath, destItemPath);
+		return 0;
+	}
+	static int Polycode_Core_removeDiskItem(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String itemPath = String(lua_tostring(L, 2));
+		inst->removeDiskItem(itemPath);
+		return 0;
+	}
+	static int Polycode_Core_openFolderPicker(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushstring(L, inst->openFolderPicker().c_str());
+		return 1;
+	}
+	static int Polycode_Core_setFramerate(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int frameRate = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int maxFixedCycles = lua_tointeger(L, 3);
+		inst->setFramerate(frameRate, maxFixedCycles);
+		return 0;
+	}
+	static int Polycode_Core_openFilePicker(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		vector<CoreFileExtension> extensions = *(vector<CoreFileExtension>*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool allowMultiple = lua_toboolean(L, 3) != 0;
+	}
+	static int Polycode_Core_saveFilePicker(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		vector<CoreFileExtension> extensions = *(vector<CoreFileExtension>*) *((PolyBase**)lua_touserdata(L, 2));
+		lua_pushstring(L, inst->saveFilePicker(extensions).c_str());
+		return 1;
+	}
+	static int Polycode_Core_handleVideoModeChange(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		VideoModeChangeInfo* modeInfo = (VideoModeChangeInfo*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->handleVideoModeChange(modeInfo);
+		return 0;
+	}
+	static int Polycode_Core_flushRenderContext(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->flushRenderContext();
+		return 0;
+	}
+	static int Polycode_Core_prepareRenderContext(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->prepareRenderContext();
+		return 0;
+	}
+	static int Polycode_Core_openFile(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String opts = String(lua_tostring(L, 3));
+		PolyBase *ptrRetVal = (PolyBase*)inst->openFile(fileName, opts);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Core_closeFile(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		CoreFile* file = (CoreFile*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->closeFile(file);
+		return 0;
+	}
+	static int Polycode_Core_addFileSource(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String type = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String source = String(lua_tostring(L, 3));
+		inst->addFileSource(type, source);
+		return 0;
+	}
+	static int Polycode_Core_removeFileSource(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String type = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String source = String(lua_tostring(L, 3));
+		inst->removeFileSource(type, source);
+		return 0;
+	}
+	static int Polycode_Core_parseFolder(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String pathString = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool showHidden = lua_toboolean(L, 3) != 0;
+	}
+	static int Polycode_Core_systemParseFolder(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String pathString = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool showHidden = lua_toboolean(L, 3) != 0;
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		vector<OSFileEntry> targetVector = *(vector<OSFileEntry>*) *((PolyBase**)lua_touserdata(L, 4));
+		lua_pushboolean(L, inst->systemParseFolder(pathString, showHidden, targetVector));
+		return 1;
+	}
+	static int Polycode_Core_getResourcePathForFile(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 2));
+		lua_pushstring(L, inst->getResourcePathForFile(fileName).c_str());
+		return 1;
+	}
+	static int Polycode_Core_setVideoMode(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int xRes = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int yRes = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TBOOLEAN);
+		bool fullScreen = lua_toboolean(L, 4) != 0;
+		luaL_checktype(L, 5, LUA_TBOOLEAN);
+		bool vSync = lua_toboolean(L, 5) != 0;
+		luaL_checktype(L, 6, LUA_TNUMBER);
+		int aaLevel = lua_tointeger(L, 6);
+		luaL_checktype(L, 7, LUA_TNUMBER);
+		int anisotropyLevel = lua_tointeger(L, 7);
+		luaL_checktype(L, 8, LUA_TBOOLEAN);
+		bool retinaSupport = lua_toboolean(L, 8) != 0;
+		inst->setVideoMode(xRes, yRes, fullScreen, vSync, aaLevel, anisotropyLevel, retinaSupport);
+		return 0;
+	}
+	static int Polycode_Core_resizeTo(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int xRes = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int yRes = lua_tointeger(L, 3);
+		inst->resizeTo(xRes, yRes);
+		return 0;
+	}
+	static int Polycode_Core_doSleep(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->doSleep();
+		return 0;
+	}
+	static int Polycode_Core_openURL(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String url = String(lua_tostring(L, 2));
+		inst->openURL(url);
+		return 0;
+	}
+	static int Polycode_Core_getElapsed(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getElapsed());
+		return 1;
+	}
+	static int Polycode_Core_getTicks(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getTicks());
+		return 1;
+	}
+	static int Polycode_Core_getRefreshIntervalMs(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getRefreshIntervalMs());
+		return 1;
+	}
+	static int Polycode_Core_getTimeSleptMs(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getTimeSleptMs());
+		return 1;
+	}
+	static int Polycode_Core_getFixedTimestep(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getFixedTimestep());
+		return 1;
+	}
+	static int Polycode_Core_getTicksFloat(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getTicksFloat());
+		return 1;
+	}
+	static int Polycode_Core_setUserPointer(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		void* ptr = (void*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setUserPointer(ptr);
+		return 0;
+	}
+	static int Polycode_Core_getUserPointer(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getUserPointer();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Core_executeExternalCommand(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String command = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String args = String(lua_tostring(L, 3));
+		luaL_checktype(L, 4, LUA_TSTRING);
+		String inDirectory = String(lua_tostring(L, 4));
+		lua_pushstring(L, inst->executeExternalCommand(command, args, inDirectory).c_str());
+		return 1;
+	}
+	static int Polycode_Core_getDefaultWorkingDirectory(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushstring(L, inst->getDefaultWorkingDirectory().c_str());
+		return 1;
+	}
+	static int Polycode_Core_getUserHomeDirectory(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushstring(L, inst->getUserHomeDirectory().c_str());
+		return 1;
+	}
+	static int Polycode_Core_makeApplicationMain(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->makeApplicationMain();
+		return 0;
+	}
+	static int Polycode_Core_getEventMutex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getEventMutex();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Core_removeThread(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Core *inst = (Core*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Threaded* thread = (Threaded*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->removeThread(thread);
+		return 0;
+	}
+	static int Polycode_PolycodeViewBase(lua_State *L) {
+		PolycodeViewBase *inst = new PolycodeViewBase();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.PolycodeViewBase");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_DummyCore(lua_State *L) {
+		DummyCore *inst = new DummyCore();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.DummyCore");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_DummyCore_Render(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		DummyCore *inst = (DummyCore*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->Render();
+		return 0;
+	}
+	static int Polycode_DummyCore_systemUpdate(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		DummyCore *inst = (DummyCore*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->systemUpdate());
+		return 1;
+	}
+	static int Polycode_DummyCore_setCursor(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		DummyCore *inst = (DummyCore*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int cursorType = lua_tointeger(L, 2);
+		inst->setCursor(cursorType);
+		return 0;
+	}
+	static int Polycode_DummyCore_createThread(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		DummyCore *inst = (DummyCore*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Threaded* target = (Threaded*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->createThread(target);
+		return 0;
+	}
+	static int Polycode_DummyCore_createMutex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		DummyCore *inst = (DummyCore*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->createMutex();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_DummyCore_copyStringToClipboard(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		DummyCore *inst = (DummyCore*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String str = String(lua_tostring(L, 2));
+		inst->copyStringToClipboard(str);
+		return 0;
+	}
+	static int Polycode_DummyCore_getClipboardString(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		DummyCore *inst = (DummyCore*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushstring(L, inst->getClipboardString().c_str());
+		return 1;
+	}
+	static int Polycode_DummyCore_createFolder(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		DummyCore *inst = (DummyCore*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String folderPath = String(lua_tostring(L, 2));
+		inst->createFolder(folderPath);
+		return 0;
+	}
+	static int Polycode_DummyCore_copyDiskItem(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		DummyCore *inst = (DummyCore*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String itemPath = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String destItemPath = String(lua_tostring(L, 3));
+		inst->copyDiskItem(itemPath, destItemPath);
+		return 0;
+	}
+	static int Polycode_DummyCore_moveDiskItem(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		DummyCore *inst = (DummyCore*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String itemPath = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String destItemPath = String(lua_tostring(L, 3));
+		inst->moveDiskItem(itemPath, destItemPath);
+		return 0;
+	}
+	static int Polycode_DummyCore_removeDiskItem(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		DummyCore *inst = (DummyCore*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String itemPath = String(lua_tostring(L, 2));
+		inst->removeDiskItem(itemPath);
+		return 0;
+	}
+	static int Polycode_DummyCore_openFolderPicker(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		DummyCore *inst = (DummyCore*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushstring(L, inst->openFolderPicker().c_str());
+		return 1;
+	}
+	static int Polycode_DummyCore_openFilePicker(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		DummyCore *inst = (DummyCore*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		vector<CoreFileExtension> extensions = *(vector<CoreFileExtension>*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool allowMultiple = lua_toboolean(L, 3) != 0;
+	}
+	static int Polycode_DummyCore_saveFilePicker(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		DummyCore *inst = (DummyCore*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		vector<CoreFileExtension> extensions = *(vector<CoreFileExtension>*) *((PolyBase**)lua_touserdata(L, 2));
+		lua_pushstring(L, inst->saveFilePicker(extensions).c_str());
+		return 1;
+	}
+	static int Polycode_DummyCore_handleVideoModeChange(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		DummyCore *inst = (DummyCore*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		VideoModeChangeInfo* modeInfo = (VideoModeChangeInfo*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->handleVideoModeChange(modeInfo);
+		return 0;
+	}
+	static int Polycode_DummyCore_flushRenderContext(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		DummyCore *inst = (DummyCore*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->flushRenderContext();
+		return 0;
+	}
+	static int Polycode_DummyCore_openURL(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		DummyCore *inst = (DummyCore*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String url = String(lua_tostring(L, 2));
+		inst->openURL(url);
+		return 0;
+	}
+	static int Polycode_DummyCore_getTicks(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		DummyCore *inst = (DummyCore*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getTicks());
+		return 1;
+	}
+	static int Polycode_DummyCore_executeExternalCommand(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		DummyCore *inst = (DummyCore*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String command = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String args = String(lua_tostring(L, 3));
+		luaL_checktype(L, 4, LUA_TSTRING);
+		String inDirectory = String(lua_tostring(L, 4));
+		lua_pushstring(L, inst->executeExternalCommand(command, args, inDirectory).c_str());
+		return 1;
+	}
+	static int Polycode_DummyCore_systemParseFolder(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		DummyCore *inst = (DummyCore*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String pathString = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool showHidden = lua_toboolean(L, 3) != 0;
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		vector<OSFileEntry> targetVector = *(vector<OSFileEntry>*) *((PolyBase**)lua_touserdata(L, 4));
+		lua_pushboolean(L, inst->systemParseFolder(pathString, showHidden, targetVector));
+		return 1;
+	}
+	static int Polycode_TimeInfo(lua_State *L) {
+		TimeInfo *inst = new TimeInfo();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.TimeInfo");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_CoreMutex_lock(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreMutex *inst = (CoreMutex*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->lock();
+		return 0;
+	}
+	static int Polycode_CoreMutex_unlock(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreMutex *inst = (CoreMutex*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->unlock();
+		return 0;
+	}
+	static int Polycode_CoreFileExtension(lua_State *L) {
+		CoreFileExtension *inst = new CoreFileExtension();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.CoreFileExtension");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_OSFileEntry(lua_State *L) {
+		OSFileEntry *inst = new OSFileEntry();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.OSFileEntry");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_OSFileEntry_init(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OSFileEntry *inst = (OSFileEntry*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String path = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String name = String(lua_tostring(L, 3));
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int type = lua_tointeger(L, 4);
+		inst->init(path, name, type);
+		return 0;
+	}
+	static int Polycode_CoreInput(lua_State *L) {
+		CoreInput *inst = new CoreInput();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.CoreInput");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_CoreInput_getMousePosition(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreInput *inst = (CoreInput*) *((PolyBase**)lua_touserdata(L, 1));
+		Vector2 *retInst = new Vector2();
+		*retInst = inst->getMousePosition();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector2");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_CoreInput_getKeyState(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreInput *inst = (CoreInput*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		PolyKEY keyCode = (PolyKEY)lua_tointeger(L, 2);
+		lua_pushboolean(L, inst->getKeyState(keyCode));
+		return 1;
+	}
+	static int Polycode_CoreInput_getJoystickButtonState(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreInput *inst = (CoreInput*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int joystickIndex = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int button = lua_tointeger(L, 3);
+		lua_pushboolean(L, inst->getJoystickButtonState(joystickIndex, button));
+		return 1;
+	}
+	static int Polycode_CoreInput_getJoystickAxisValue(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreInput *inst = (CoreInput*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int joystickIndex = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int axis = lua_tointeger(L, 3);
+		lua_pushnumber(L, inst->getJoystickAxisValue(joystickIndex, axis));
+		return 1;
+	}
+	static int Polycode_CoreInput_getMouseDelta(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreInput *inst = (CoreInput*) *((PolyBase**)lua_touserdata(L, 1));
+		Vector2 *retInst = new Vector2();
+		*retInst = inst->getMouseDelta();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector2");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_CoreInput_getMouseButtonState(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreInput *inst = (CoreInput*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int mouseButton = lua_tointeger(L, 2);
+		lua_pushboolean(L, inst->getMouseButtonState(mouseButton));
+		return 1;
+	}
+	static int Polycode_CoreInput_getNumJoysticks(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreInput *inst = (CoreInput*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getNumJoysticks());
+		return 1;
+	}
+	static int Polycode_CoreInput_getJoystickInfoByIndex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreInput *inst = (CoreInput*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->getJoystickInfoByIndex(index);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_CoreInput_getJoystickInfoByID(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreInput *inst = (CoreInput*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int deviceID = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->getJoystickInfoByID(deviceID);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_CoreInput_addJoystick(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreInput *inst = (CoreInput*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int deviceID = lua_tointeger(L, 2);
+		inst->addJoystick(deviceID);
+		return 0;
+	}
+	static int Polycode_CoreInput_removeJoystick(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreInput *inst = (CoreInput*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int deviceID = lua_tointeger(L, 2);
+		inst->removeJoystick(deviceID);
+		return 0;
+	}
+	static int Polycode_CoreInput_joystickAxisMoved(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreInput *inst = (CoreInput*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int axisID = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number value = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int deviceID = lua_tointeger(L, 4);
+		inst->joystickAxisMoved(axisID, value, deviceID);
+		return 0;
+	}
+	static int Polycode_CoreInput_joystickButtonDown(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreInput *inst = (CoreInput*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int buttonID = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int deviceID = lua_tointeger(L, 3);
+		inst->joystickButtonDown(buttonID, deviceID);
+		return 0;
+	}
+	static int Polycode_CoreInput_joystickButtonUp(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreInput *inst = (CoreInput*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int buttonID = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int deviceID = lua_tointeger(L, 3);
+		inst->joystickButtonUp(buttonID, deviceID);
+		return 0;
+	}
+	static int Polycode_CoreInput_mouseWheelUp(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreInput *inst = (CoreInput*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int ticks = lua_tointeger(L, 2);
+		inst->mouseWheelUp(ticks);
+		return 0;
+	}
+	static int Polycode_CoreInput_mouseWheelDown(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreInput *inst = (CoreInput*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int ticks = lua_tointeger(L, 2);
+		inst->mouseWheelDown(ticks);
+		return 0;
+	}
+	static int Polycode_CoreInput_setMouseButtonState(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreInput *inst = (CoreInput*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int mouseButton = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool state = lua_toboolean(L, 3) != 0;
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int ticks = lua_tointeger(L, 4);
+		inst->setMouseButtonState(mouseButton, state, ticks);
+		return 0;
+	}
+	static int Polycode_CoreInput_setMousePosition(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreInput *inst = (CoreInput*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int x = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int y = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int ticks = lua_tointeger(L, 4);
+		inst->setMousePosition(x, y, ticks);
+		return 0;
+	}
+	static int Polycode_CoreInput_setKeyState(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreInput *inst = (CoreInput*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		PolyKEY keyCode = (PolyKEY)lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		wchar_t code = *(wchar_t*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TBOOLEAN);
+		bool newState = lua_toboolean(L, 4) != 0;
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		int ticks = lua_tointeger(L, 5);
+		inst->setKeyState(keyCode, code, newState, ticks);
+		return 0;
+	}
+	static int Polycode_CoreInput_setDeltaPosition(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreInput *inst = (CoreInput*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int x = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int y = lua_tointeger(L, 3);
+		inst->setDeltaPosition(x, y);
+		return 0;
+	}
+	static int Polycode_CoreInput_touchesBegan(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreInput *inst = (CoreInput*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		TouchInfo touch = *(TouchInfo*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		vector<TouchInfo> touches = *(vector<TouchInfo>*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int ticks = lua_tointeger(L, 4);
+		inst->touchesBegan(touch, touches, ticks);
+		return 0;
+	}
+	static int Polycode_CoreInput_touchesMoved(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreInput *inst = (CoreInput*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		TouchInfo touch = *(TouchInfo*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		vector<TouchInfo> touches = *(vector<TouchInfo>*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int ticks = lua_tointeger(L, 4);
+		inst->touchesMoved(touch, touches, ticks);
+		return 0;
+	}
+	static int Polycode_CoreInput_touchesEnded(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreInput *inst = (CoreInput*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		TouchInfo touch = *(TouchInfo*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		vector<TouchInfo> touches = *(vector<TouchInfo>*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int ticks = lua_tointeger(L, 4);
+		inst->touchesEnded(touch, touches, ticks);
+		return 0;
+	}
+	static int Polycode_CoreInput_createEvent(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreInput *inst = (CoreInput*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Event* event = (Event*) *((PolyBase**)lua_touserdata(L, 2));
+		PolyBase *ptrRetVal = (PolyBase*)inst->createEvent(event);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_CoreInput_clearInput(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreInput *inst = (CoreInput*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->clearInput();
+		return 0;
+	}
+	static int Polycode_JoystickInfo(lua_State *L) {
+		JoystickInfo *inst = new JoystickInfo();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.JoystickInfo");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_CoreServices_getInstance(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreServices *inst = (CoreServices*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getInstance();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_CoreServices_setInstance(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreServices *inst = (CoreServices*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		CoreServices* _instance = (CoreServices*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setInstance(_instance);
+		return 0;
+	}
+	static int Polycode_CoreServices_getRenderMutex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreServices *inst = (CoreServices*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getRenderMutex();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_CoreServices_createInstance(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreServices *inst = (CoreServices*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->createInstance();
+		return 0;
+	}
+	static int Polycode_CoreServices_setRenderer(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreServices *inst = (CoreServices*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Renderer* renderer = (Renderer*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setRenderer(renderer);
+		return 0;
+	}
+	static int Polycode_CoreServices_getRenderer(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreServices *inst = (CoreServices*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getRenderer();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_CoreServices_Update(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreServices *inst = (CoreServices*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int elapsed = lua_tointeger(L, 2);
+		inst->Update(elapsed);
+		return 0;
+	}
+	static int Polycode_CoreServices_fixedUpdate(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreServices *inst = (CoreServices*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->fixedUpdate();
+		return 0;
+	}
+	static int Polycode_CoreServices_Render(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreServices *inst = (CoreServices*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Polycode::Rectangle viewport = *(Polycode::Rectangle*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->Render(viewport);
+		return 0;
+	}
+	static int Polycode_CoreServices_setCore(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreServices *inst = (CoreServices*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Core* core = (Core*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setCore(core);
+		return 0;
+	}
+	static int Polycode_CoreServices_getCore(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreServices *inst = (CoreServices*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getCore();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_CoreServices_getInput(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreServices *inst = (CoreServices*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getInput();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_CoreServices_getMaterialManager(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreServices *inst = (CoreServices*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getMaterialManager();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_CoreServices_getSceneManager(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreServices *inst = (CoreServices*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getSceneManager();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_CoreServices_getTimerManager(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreServices *inst = (CoreServices*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getTimerManager();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_CoreServices_getTweenManager(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreServices *inst = (CoreServices*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getTweenManager();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_CoreServices_getResourceManager(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreServices *inst = (CoreServices*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getResourceManager();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_CoreServices_getSoundManager(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreServices *inst = (CoreServices*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getSoundManager();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_CoreServices_getLogger(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreServices *inst = (CoreServices*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getLogger();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_CoreServices_getConfig(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		CoreServices *inst = (CoreServices*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getConfig();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Cubemap(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Texture* t0 = (Texture*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Texture* t1 = (Texture*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Texture* t2 = (Texture*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		Texture* t3 = (Texture*) *((PolyBase**)lua_touserdata(L, 4));
+		luaL_checktype(L, 5, LUA_TUSERDATA);
+		Texture* t4 = (Texture*) *((PolyBase**)lua_touserdata(L, 5));
+		luaL_checktype(L, 6, LUA_TUSERDATA);
+		Texture* t5 = (Texture*) *((PolyBase**)lua_touserdata(L, 6));
+		Cubemap *inst = new Cubemap(t0, t1, t2, t3, t4, t5);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.Cubemap");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Cubemap_getTexture(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Cubemap *inst = (Cubemap*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->getTexture(index);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Cubemap_setTexture(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Cubemap *inst = (Cubemap*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Texture* texture = (Texture*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int index = lua_tointeger(L, 3);
+		inst->setTexture(texture, index);
+		return 0;
+	}
+	static int Polycode_Cubemap_recreateFromTextures(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Cubemap *inst = (Cubemap*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->recreateFromTextures();
+		return 0;
+	}
+	static int Polycode_Data(lua_State *L) {
+		Data *inst = new Data();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.Data");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Data_loadFromFile(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Data *inst = (Data*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 2));
+		lua_pushboolean(L, inst->loadFromFile(fileName));
+		return 1;
+	}
+	static int Polycode_Data_getAsString(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Data *inst = (Data*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int encoding = lua_tointeger(L, 2);
+		lua_pushstring(L, inst->getAsString(encoding).c_str());
+		return 1;
+	}
+	static int Polycode_Data_setFromString(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Data *inst = (Data*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String str = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int encoding = lua_tointeger(L, 3);
+		inst->setFromString(str, encoding);
+		return 0;
+	}
+	static int Polycode_Data_saveToFile(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Data *inst = (Data*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 2));
+		lua_pushboolean(L, inst->saveToFile(fileName));
+		return 1;
+	}
+	static int Polycode_Data_getData(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Data *inst = (Data*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getData();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Rotation(lua_State *L) {
+		Rotation *inst = new Rotation();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.Rotation");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Entity(lua_State *L) {
+		Entity *inst = new Entity();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.Entity");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Entity_initEntity(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->initEntity();
+		return 0;
+	}
+	static int Polycode_Entity_Render(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		GPUDrawBuffer* buffer = (GPUDrawBuffer*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->Render(buffer);
+		return 0;
+	}
+	static int Polycode_Entity_Update(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->Update();
+		return 0;
+	}
+	static int Polycode_Entity_fixedUpdate(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->fixedUpdate();
+		return 0;
+	}
+	static int Polycode_Entity_transformAndRender(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		GPUDrawBuffer* drawBuffer = (GPUDrawBuffer*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Polycode::Rectangle* parentScissorBox = (Polycode::Rectangle*) *((PolyBase**)lua_touserdata(L, 3));
+		inst->transformAndRender(drawBuffer, parentScissorBox);
+		return 0;
+	}
+	static int Polycode_Entity_renderChildren(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		GPUDrawBuffer* buffer = (GPUDrawBuffer*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Polycode::Rectangle* parentScissorBox = (Polycode::Rectangle*) *((PolyBase**)lua_touserdata(L, 3));
+		inst->renderChildren(buffer, parentScissorBox);
+		return 0;
+	}
+	static int Polycode_Entity_Clone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool deepClone = lua_toboolean(L, 2) != 0;
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool ignoreEditorOnly = lua_toboolean(L, 3) != 0;
+		PolyBase *ptrRetVal = (PolyBase*)inst->Clone(deepClone, ignoreEditorOnly);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Entity_applyClone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Entity* clone = (Entity*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool deepClone = lua_toboolean(L, 3) != 0;
+		luaL_checktype(L, 4, LUA_TBOOLEAN);
+		bool ignoreEditorOnly = lua_toboolean(L, 4) != 0;
+		inst->applyClone(clone, deepClone, ignoreEditorOnly);
+		return 0;
+	}
+	static int Polycode_Entity_dirtyMatrix(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool val = lua_toboolean(L, 2) != 0;
+		inst->dirtyMatrix(val);
+		return 0;
+	}
+	static int Polycode_Entity_rebuildTransformMatrix(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->rebuildTransformMatrix();
+		return 0;
+	}
+	static int Polycode_Entity_updateEntityMatrix(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->updateEntityMatrix();
+		return 0;
+	}
+	static int Polycode_Entity_getTransformMatrix(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		Matrix4 *retInst = new Matrix4();
+		*retInst = inst->getTransformMatrix();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Matrix4");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Entity_getConcatenatedMatrix(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		Matrix4 *retInst = new Matrix4();
+		*retInst = inst->getConcatenatedMatrix();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Matrix4");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Entity_getConcatenatedMatrixRelativeTo(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Entity* relativeEntity = (Entity*) *((PolyBase**)lua_touserdata(L, 2));
+		Matrix4 *retInst = new Matrix4();
+		*retInst = inst->getConcatenatedMatrixRelativeTo(relativeEntity);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Matrix4");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Entity_getAnchorAdjustedMatrix(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		Matrix4 *retInst = new Matrix4();
+		*retInst = inst->getAnchorAdjustedMatrix();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Matrix4");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Entity_getConcatenatedRollMatrix(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		Matrix4 *retInst = new Matrix4();
+		*retInst = inst->getConcatenatedRollMatrix();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Matrix4");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Entity_setTransformByMatrixPure(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Matrix4 matrix = *(Matrix4*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setTransformByMatrixPure(matrix);
+		return 0;
+	}
+	static int Polycode_Entity_getLookAtMatrix(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 loc = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Vector3 upVector = *(Vector3*) *((PolyBase**)lua_touserdata(L, 3));
+		Matrix4 *retInst = new Matrix4();
+		*retInst = inst->getLookAtMatrix(loc, upVector);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Matrix4");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Entity_addChild(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Entity* newChild = (Entity*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->addChild(newChild);
+		return 0;
+	}
+	static int Polycode_Entity_removeChild(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Entity* entityToRemove = (Entity*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->removeChild(entityToRemove);
+		return 0;
+	}
+	static int Polycode_Entity_moveChildUp(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Entity* child = (Entity*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->moveChildUp(child);
+		return 0;
+	}
+	static int Polycode_Entity_moveChildDown(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Entity* child = (Entity*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->moveChildDown(child);
+		return 0;
+	}
+	static int Polycode_Entity_moveChildTop(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Entity* child = (Entity*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->moveChildTop(child);
+		return 0;
+	}
+	static int Polycode_Entity_moveChildBottom(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Entity* child = (Entity*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->moveChildBottom(child);
+		return 0;
+	}
+	static int Polycode_Entity_setParentEntity(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Entity* entity = (Entity*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setParentEntity(entity);
+		return 0;
+	}
+	static int Polycode_Entity_getParentEntity(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getParentEntity();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Entity_getNumChildren(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getNumChildren());
+		return 1;
+	}
+	static int Polycode_Entity_getChildAtIndex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->getChildAtIndex(index);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Entity_setOwnsChildrenRecursive(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool val = lua_toboolean(L, 2) != 0;
+		inst->setOwnsChildrenRecursive(val);
+		return 0;
+	}
+	static int Polycode_Entity_getPosition(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->getPosition();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Entity_getPosition2D(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		Vector2 *retInst = new Vector2();
+		*retInst = inst->getPosition2D();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector2");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Entity_getCombinedPosition(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->getCombinedPosition();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Entity_setPosition(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number z = lua_tonumber(L, 4);
+		inst->setPosition(x, y, z);
+		return 0;
+	}
+	static int Polycode_Entity_setPositionX(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 2);
+		inst->setPositionX(x);
+		return 0;
+	}
+	static int Polycode_Entity_setPositionY(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 2);
+		inst->setPositionY(y);
+		return 0;
+	}
+	static int Polycode_Entity_Translate(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number z = lua_tonumber(L, 4);
+		inst->Translate(x, y, z);
+		return 0;
+	}
+	static int Polycode_Entity_setPositionZ(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number z = lua_tonumber(L, 2);
+		inst->setPositionZ(z);
+		return 0;
+	}
+	static int Polycode_Entity_setScaleX(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 2);
+		inst->setScaleX(x);
+		return 0;
+	}
+	static int Polycode_Entity_setScaleY(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 2);
+		inst->setScaleY(y);
+		return 0;
+	}
+	static int Polycode_Entity_setScaleZ(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number z = lua_tonumber(L, 2);
+		inst->setScaleZ(z);
+		return 0;
+	}
+	static int Polycode_Entity_Scale(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number z = lua_tonumber(L, 4);
+		inst->Scale(x, y, z);
+		return 0;
+	}
+	static int Polycode_Entity_setScale(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number z = lua_tonumber(L, 4);
+		inst->setScale(x, y, z);
+		return 0;
+	}
+	static int Polycode_Entity_getCompoundScale(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->getCompoundScale();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Entity_getScale(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->getScale();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Entity_getRotationEuler(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->getRotationEuler();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Entity_getCombinedPitch(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getCombinedPitch());
+		return 1;
+	}
+	static int Polycode_Entity_getCombinedYaw(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getCombinedYaw());
+		return 1;
+	}
+	static int Polycode_Entity_getCombinedRoll(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getCombinedRoll());
+		return 1;
+	}
+	static int Polycode_Entity_rebuildRotation(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->rebuildRotation();
+		return 0;
+	}
+	static int Polycode_Entity_setRotationEuler(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 rotation = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setRotationEuler(rotation);
+		return 0;
+	}
+	static int Polycode_Entity_setPitch(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number pitch = lua_tonumber(L, 2);
+		inst->setPitch(pitch);
+		return 0;
+	}
+	static int Polycode_Entity_setYaw(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number yaw = lua_tonumber(L, 2);
+		inst->setYaw(yaw);
+		return 0;
+	}
+	static int Polycode_Entity_setRoll(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number roll = lua_tonumber(L, 2);
+		inst->setRoll(roll);
+		return 0;
+	}
+	static int Polycode_Entity_Roll(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number roll = lua_tonumber(L, 2);
+		inst->Roll(roll);
+		return 0;
+	}
+	static int Polycode_Entity_Yaw(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number yaw = lua_tonumber(L, 2);
+		inst->Yaw(yaw);
+		return 0;
+	}
+	static int Polycode_Entity_Pitch(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number pitch = lua_tonumber(L, 2);
+		inst->Pitch(pitch);
+		return 0;
+	}
+	static int Polycode_Entity_getPitch(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getPitch());
+		return 1;
+	}
+	static int Polycode_Entity_getYaw(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getYaw());
+		return 1;
+	}
+	static int Polycode_Entity_getRoll(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getRoll());
+		return 1;
+	}
+	static int Polycode_Entity_getWidth(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getWidth());
+		return 1;
+	}
+	static int Polycode_Entity_getHeight(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getHeight());
+		return 1;
+	}
+	static int Polycode_Entity_getDepth(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getDepth());
+		return 1;
+	}
+	static int Polycode_Entity_setWidth(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number width = lua_tonumber(L, 2);
+		inst->setWidth(width);
+		return 0;
+	}
+	static int Polycode_Entity_setHeight(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number height = lua_tonumber(L, 2);
+		inst->setHeight(height);
+		return 0;
+	}
+	static int Polycode_Entity_setDepth(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number depth = lua_tonumber(L, 2);
+		inst->setDepth(depth);
+		return 0;
+	}
+	static int Polycode_Entity_setRotationQuat(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number w = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number z = lua_tonumber(L, 5);
+		inst->setRotationQuat(w, x, y, z);
+		return 0;
+	}
+	static int Polycode_Entity_setRotationByQuaternion(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Quaternion quaternion = *(Quaternion*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setRotationByQuaternion(quaternion);
+		return 0;
+	}
+	static int Polycode_Entity_getRotationQuat(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		Quaternion *retInst = new Quaternion();
+		*retInst = inst->getRotationQuat();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Quaternion");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Entity_getConcatenatedQuat(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		Quaternion *retInst = new Quaternion();
+		*retInst = inst->getConcatenatedQuat();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Quaternion");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Entity_lookAt(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 loc = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Vector3 upVector = *(Vector3*) *((PolyBase**)lua_touserdata(L, 3));
+		inst->lookAt(loc, upVector);
+		return 0;
+	}
+	static int Polycode_Entity_lookAtEntity(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Entity* entity = (Entity*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Vector3 upVector = *(Vector3*) *((PolyBase**)lua_touserdata(L, 3));
+		inst->lookAtEntity(entity, upVector);
+		return 0;
+	}
+	static int Polycode_Entity_getCombinedColor(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		Color *retInst = new Color();
+		*retInst = inst->getCombinedColor();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Color");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Entity_setColor(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number r = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number g = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number b = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number a = lua_tonumber(L, 5);
+		inst->setColor(r, g, b, a);
+		return 0;
+	}
+	static int Polycode_Entity_setColorInt(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int r = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int g = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int b = lua_tointeger(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		int a = lua_tointeger(L, 5);
+		inst->setColorInt(r, g, b, a);
+		return 0;
+	}
+	static int Polycode_Entity_setAnchorPoint(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 anchorPoint = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setAnchorPoint(anchorPoint);
+		return 0;
+	}
+	static int Polycode_Entity_getAnchorPoint(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->getAnchorPoint();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Entity_onMouseDown(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Ray ray = *(Ray*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int mouseButton = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int timestamp = lua_tointeger(L, 4);
+		MouseEventResult *retInst = new MouseEventResult();
+		*retInst = inst->onMouseDown(ray, mouseButton, timestamp);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.MouseEventResult");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Entity_onMouseUp(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Ray ray = *(Ray*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int mouseButton = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int timestamp = lua_tointeger(L, 4);
+		MouseEventResult *retInst = new MouseEventResult();
+		*retInst = inst->onMouseUp(ray, mouseButton, timestamp);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.MouseEventResult");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Entity_onMouseMove(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Ray ray = *(Ray*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int timestamp = lua_tointeger(L, 3);
+		MouseEventResult *retInst = new MouseEventResult();
+		*retInst = inst->onMouseMove(ray, timestamp);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.MouseEventResult");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Entity_onMouseWheelUp(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Ray ray = *(Ray*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int timestamp = lua_tointeger(L, 3);
+		MouseEventResult *retInst = new MouseEventResult();
+		*retInst = inst->onMouseWheelUp(ray, timestamp);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.MouseEventResult");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Entity_onMouseWheelDown(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Ray ray = *(Ray*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int timestamp = lua_tointeger(L, 3);
+		MouseEventResult *retInst = new MouseEventResult();
+		*retInst = inst->onMouseWheelDown(ray, timestamp);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.MouseEventResult");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Entity_setDepthOnly(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool val = lua_toboolean(L, 2) != 0;
+		inst->setDepthOnly(val);
+		return 0;
+	}
+	static int Polycode_Entity_getDepthOnly(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->getDepthOnly());
+		return 1;
+	}
+	static int Polycode_Entity_setUserData(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		void* userData = (void*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setUserData(userData);
+		return 0;
+	}
+	static int Polycode_Entity_getUserData(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getUserData();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Entity_setBlendingMode(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int newBlendingMode = lua_tointeger(L, 2);
+		inst->setBlendingMode(newBlendingMode);
+		return 0;
+	}
+	static int Polycode_Entity_getBlendingMode(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getBlendingMode());
+		return 1;
+	}
+	static int Polycode_Entity_getEntityById(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String id = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool recursive = lua_toboolean(L, 3) != 0;
+		PolyBase *ptrRetVal = (PolyBase*)inst->getEntityById(id, recursive);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Entity_getEntitiesByTag(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String tag = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool recursive = lua_toboolean(L, 3) != 0;
+	}
+	static int Polycode_Entity_getEntitiesByLayerID(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		char layerID = *(char*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool recursive = lua_toboolean(L, 3) != 0;
+	}
+	static int Polycode_Entity_getEntityProp(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String propName = String(lua_tostring(L, 2));
+		lua_pushstring(L, inst->getEntityProp(propName).c_str());
+		return 1;
+	}
+	static int Polycode_Entity_setEntityProp(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String propName = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String propValue = String(lua_tostring(L, 3));
+		inst->setEntityProp(propName, propValue);
+		return 0;
+	}
+	static int Polycode_Entity_setInverseY(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool val = lua_toboolean(L, 2) != 0;
+		inst->setInverseY(val);
+		return 0;
+	}
+	static int Polycode_Entity_getInverseY(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->getInverseY());
+		return 1;
+	}
+	static int Polycode_Entity_doUpdates(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->doUpdates();
+		return 0;
+	}
+	static int Polycode_Entity_doFixedUpdates(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->doFixedUpdates();
+		return 0;
+	}
+	static int Polycode_Entity_buildPositionMatrix(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		Matrix4 *retInst = new Matrix4();
+		*retInst = inst->buildPositionMatrix();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Matrix4");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Entity_setRenderer(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Renderer* renderer = (Renderer*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setRenderer(renderer);
+		return 0;
+	}
+	static int Polycode_Entity_customHitDetection(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Ray ray = *(Ray*) *((PolyBase**)lua_touserdata(L, 2));
+		lua_pushboolean(L, inst->customHitDetection(ray));
+		return 1;
+	}
+	static int Polycode_Entity_getNumTags(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getNumTags());
+		return 1;
+	}
+	static int Polycode_Entity_getTagAtIndex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		lua_pushstring(L, inst->getTagAtIndex(index).c_str());
+		return 1;
+	}
+	static int Polycode_Entity_hasTag(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String tag = String(lua_tostring(L, 2));
+		lua_pushboolean(L, inst->hasTag(tag));
+		return 1;
+	}
+	static int Polycode_Entity_clearTags(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->clearTags();
+		return 0;
+	}
+	static int Polycode_Entity_addTag(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String tag = String(lua_tostring(L, 2));
+		inst->addTag(tag);
+		return 0;
+	}
+	static int Polycode_Entity_getScreenPosition(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Matrix4 projectionMatrix = *(Matrix4*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Matrix4 cameraMatrix = *(Matrix4*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		Polycode::Rectangle viewport = *(Polycode::Rectangle*) *((PolyBase**)lua_touserdata(L, 4));
+		Vector2 *retInst = new Vector2();
+		*retInst = inst->getScreenPosition(projectionMatrix, cameraMatrix, viewport);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector2");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Entity_recalculateAABBAllChildren(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->recalculateAABBAllChildren();
+		return 0;
+	}
+	static int Polycode_Entity_recalculateAABB(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->recalculateAABB();
+		return 0;
+	}
+	static int Polycode_Entity_getWorldAABB(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		AABB *retInst = new AABB();
+		*retInst = inst->getWorldAABB();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.AABB");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Entity_getLocalBoundingBox(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->getLocalBoundingBox();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Entity_setLocalBoundingBox(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 box = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setLocalBoundingBox(box);
+		return 0;
+	}
+	static int Polycode_Entity_setLocalBoundingBoxX(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 2);
+		inst->setLocalBoundingBoxX(x);
+		return 0;
+	}
+	static int Polycode_Entity_setLocalBoundingBoxY(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 2);
+		inst->setLocalBoundingBoxY(y);
+		return 0;
+	}
+	static int Polycode_Entity_setLocalBoundingBoxZ(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number z = lua_tonumber(L, 2);
+		inst->setLocalBoundingBoxZ(z);
+		return 0;
+	}
+	static int Polycode_Entity_setContainerScene(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Scene* scene = (Scene*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setContainerScene(scene);
+		return 0;
+	}
+	static int Polycode_Entity_getContainerScene(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getContainerScene();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Entity_attachScript(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Script* script = (Script*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->attachScript(script);
+		return 0;
+	}
+	static int Polycode_Entity_detachScript(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Script* script = (Script*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->detachScript(script);
+		return 0;
+	}
+	static int Polycode_Entity_getNumScripts(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getNumScripts());
+		return 1;
+	}
+	static int Polycode_Entity_getScriptAtIndex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity *inst = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->getScriptAtIndex(index);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Event(lua_State *L) {
+		Event *inst = new Event();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.Event");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Event_getEventCode(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Event *inst = (Event*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getEventCode());
+		return 1;
+	}
+	static int Polycode_Event_getDispatcher(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Event *inst = (Event*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getDispatcher();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Event_setEventCode(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Event *inst = (Event*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int eventCode = lua_tointeger(L, 2);
+		inst->setEventCode(eventCode);
+		return 0;
+	}
+	static int Polycode_Event_setDispatcher(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Event *inst = (Event*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		EventDispatcher* dispatcher = (EventDispatcher*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setDispatcher(dispatcher);
+		return 0;
+	}
+	static int Polycode_Event_getEventType(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Event *inst = (Event*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushstring(L, inst->getEventType().c_str());
+		return 1;
+	}
+	static int Polycode_Event_cancelEvent(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Event *inst = (Event*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->cancelEvent();
+		return 0;
+	}
+	static int Polycode_EventDispatcher(lua_State *L) {
+		EventDispatcher *inst = new EventDispatcher();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.EventDispatcher");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_EventDispatcher_removeAllHandlers(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		EventDispatcher *inst = (EventDispatcher*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->removeAllHandlers();
+		return 0;
+	}
+	static int Polycode_EventDispatcher_removeAllHandlersForListener(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		EventDispatcher *inst = (EventDispatcher*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		EventHandler* handler = (EventHandler*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->removeAllHandlersForListener(handler);
+		return 0;
+	}
+	static int Polycode_EventDispatcher_addEventListener(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		EventDispatcher *inst = (EventDispatcher*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		EventHandler* handler = (EventHandler*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int eventCode = lua_tointeger(L, 3);
+		inst->addEventListener(handler, eventCode);
+		return 0;
+	}
+	static int Polycode_EventDispatcher_addEventListenerUnique(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		EventDispatcher *inst = (EventDispatcher*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		EventHandler* handler = (EventHandler*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int eventCode = lua_tointeger(L, 3);
+		inst->addEventListenerUnique(handler, eventCode);
+		return 0;
+	}
+	static int Polycode_EventDispatcher_hasEventListener(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		EventDispatcher *inst = (EventDispatcher*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		EventHandler* handler = (EventHandler*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int eventCode = lua_tointeger(L, 3);
+		lua_pushboolean(L, inst->hasEventListener(handler, eventCode));
+		return 1;
+	}
+	static int Polycode_EventDispatcher_removeEventListener(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		EventDispatcher *inst = (EventDispatcher*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		EventHandler* handler = (EventHandler*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int eventCode = lua_tointeger(L, 3);
+		inst->removeEventListener(handler, eventCode);
+		return 0;
+	}
+	static int Polycode_EventDispatcher___dispatchEvent(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		EventDispatcher *inst = (EventDispatcher*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Event* event = (Event*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int eventCode = lua_tointeger(L, 3);
+		inst->__dispatchEvent(event, eventCode);
+		return 0;
+	}
+	static int Polycode_EventDispatcher_dispatchEvent(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		EventDispatcher *inst = (EventDispatcher*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Event* event = (Event*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int eventCode = lua_tointeger(L, 3);
+		inst->dispatchEvent(event, eventCode);
+		return 0;
+	}
+	static int Polycode_EventDispatcher_dispatchEventNoDelete(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		EventDispatcher *inst = (EventDispatcher*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Event* event = (Event*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int eventCode = lua_tointeger(L, 3);
+		inst->dispatchEventNoDelete(event, eventCode);
+		return 0;
+	}
+	static int Polycode_EventHandler(lua_State *L) {
+		LuaEventHandler *inst = new LuaEventHandler();
+		inst->wrapperIndex = luaL_ref(L, LUA_REGISTRYINDEX );
+		inst->L = L;
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.EventHandler");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Font(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		FT_Library FTLibrary = *(FT_Library*) *((PolyBase**)lua_touserdata(L, 2));
+		Font *inst = new Font(fileName, FTLibrary);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.Font");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Font_getFace(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Font *inst = (Font*) *((PolyBase**)lua_touserdata(L, 1));
+		FT_Face *retInst = new FT_Face();
+		*retInst = inst->getFace();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.FT_Face");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Font_isValid(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Font *inst = (Font*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->isValid());
+		return 1;
+	}
+	static int Polycode_Font_setFontName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Font *inst = (Font*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String fontName = String(lua_tostring(L, 2));
+		inst->setFontName(fontName);
+		return 0;
+	}
+	static int Polycode_Font_getFontName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Font *inst = (Font*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushstring(L, inst->getFontName().c_str());
+		return 1;
+	}
+	static int Polycode_Font_getFontPath(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Font *inst = (Font*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushstring(L, inst->getFontPath().c_str());
+		return 1;
+	}
+	static int Polycode_GPUDrawBuffer(lua_State *L) {
+		GPUDrawBuffer *inst = new GPUDrawBuffer();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.GPUDrawBuffer");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Image(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 1));
+		Image *inst = new Image(fileName);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.Image");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Image_BlankImage(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Image *inst = (Image*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int width = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int height = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int type = lua_tointeger(L, 4);
+		PolyBase *ptrRetVal = (PolyBase*)inst->BlankImage(width, height, type);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Image_loadImage(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Image *inst = (Image*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 2));
+		lua_pushboolean(L, inst->loadImage(fileName));
+		return 1;
+	}
+	static int Polycode_Image_saveImage(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Image *inst = (Image*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 2));
+		lua_pushboolean(L, inst->saveImage(fileName));
+		return 1;
+	}
+	static int Polycode_Image_pasteImage(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Image *inst = (Image*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Image* image = (Image*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int x = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int y = lua_tointeger(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		int blendingMode = lua_tointeger(L, 5);
+		luaL_checktype(L, 6, LUA_TNUMBER);
+		Number blendAmount = lua_tonumber(L, 6);
+		luaL_checktype(L, 7, LUA_TUSERDATA);
+		Color blendColor = *(Color*) *((PolyBase**)lua_touserdata(L, 7));
+		inst->pasteImage(image, x, y, blendingMode, blendAmount, blendColor);
+		return 0;
+	}
+	static int Polycode_Image_createEmpty(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Image *inst = (Image*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int width = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int height = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		Color fillColor = *(Color*) *((PolyBase**)lua_touserdata(L, 4));
+		inst->createEmpty(width, height, fillColor);
+		return 0;
+	}
+	static int Polycode_Image_fill(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Image *inst = (Image*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Color color = *(Color*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->fill(color);
+		return 0;
+	}
+	static int Polycode_Image_setPixel(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Image *inst = (Image*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int x = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int y = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number r = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number g = lua_tonumber(L, 5);
+		luaL_checktype(L, 6, LUA_TNUMBER);
+		Number b = lua_tonumber(L, 6);
+		luaL_checktype(L, 7, LUA_TNUMBER);
+		Number a = lua_tonumber(L, 7);
+		inst->setPixel(x, y, r, g, b, a);
+		return 0;
+	}
+	static int Polycode_Image_getPixel(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Image *inst = (Image*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int x = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int y = lua_tointeger(L, 3);
+		Color *retInst = new Color();
+		*retInst = inst->getPixel(x, y);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Color");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Image_swap(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Image *inst = (Image*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		int* v1 = (int*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		int* v2 = (int*) *((PolyBase**)lua_touserdata(L, 3));
+		inst->swap(v1, v2);
+		return 0;
+	}
+	static int Polycode_Image_drawLine(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Image *inst = (Image*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int x0 = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int y0 = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int x1 = lua_tointeger(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		int y1 = lua_tointeger(L, 5);
+		luaL_checktype(L, 6, LUA_TUSERDATA);
+		Color col = *(Color*) *((PolyBase**)lua_touserdata(L, 6));
+		inst->drawLine(x0, y0, x1, y1, col);
+		return 0;
+	}
+	static int Polycode_Image_moveBrushTo(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Image *inst = (Image*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int x = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int y = lua_tointeger(L, 3);
+		inst->moveBrushTo(x, y);
+		return 0;
+	}
+	static int Polycode_Image_moveBrush(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Image *inst = (Image*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int x = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int y = lua_tointeger(L, 3);
+		inst->moveBrush(x, y);
+		return 0;
+	}
+	static int Polycode_Image_drawLineTo(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Image *inst = (Image*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int x = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int y = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		Color col = *(Color*) *((PolyBase**)lua_touserdata(L, 4));
+		inst->drawLineTo(x, y, col);
+		return 0;
+	}
+	static int Polycode_Image_fillRect(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Image *inst = (Image*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int x = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int y = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int w = lua_tointeger(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		int h = lua_tointeger(L, 5);
+		luaL_checktype(L, 6, LUA_TUSERDATA);
+		Color col = *(Color*) *((PolyBase**)lua_touserdata(L, 6));
+		inst->fillRect(x, y, w, h, col);
+		return 0;
+	}
+	static int Polycode_Image_perlinNoise(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Image *inst = (Image*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int seed = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool alpha = lua_toboolean(L, 3) != 0;
+		inst->perlinNoise(seed, alpha);
+		return 0;
+	}
+	static int Polycode_Image_fastBlur(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Image *inst = (Image*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int blurSize = lua_tointeger(L, 2);
+		inst->fastBlur(blurSize);
+		return 0;
+	}
+	static int Polycode_Image_fastBlurVert(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Image *inst = (Image*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int blurSize = lua_tointeger(L, 2);
+		inst->fastBlurVert(blurSize);
+		return 0;
+	}
+	static int Polycode_Image_fastBlurHor(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Image *inst = (Image*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int blurSize = lua_tointeger(L, 2);
+		inst->fastBlurHor(blurSize);
+		return 0;
+	}
+	static int Polycode_Image_getPixelsInRect(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Image *inst = (Image*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int x = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int y = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int width = lua_tointeger(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		int height = lua_tointeger(L, 5);
+		PolyBase *ptrRetVal = (PolyBase*)inst->getPixelsInRect(x, y, width, height);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Image_getImagePart(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Image *inst = (Image*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Polycode::Rectangle subRect = *(Polycode::Rectangle*) *((PolyBase**)lua_touserdata(L, 2));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getImagePart(subRect);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Image_getBrushX(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Image *inst = (Image*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getBrushX());
+		return 1;
+	}
+	static int Polycode_Image_getBrushY(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Image *inst = (Image*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getBrushY());
+		return 1;
+	}
+	static int Polycode_Image_isLoaded(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Image *inst = (Image*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->isLoaded());
+		return 1;
+	}
+	static int Polycode_Image_getType(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Image *inst = (Image*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getType());
+		return 1;
+	}
+	static int Polycode_Image_getWidth(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Image *inst = (Image*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getWidth());
+		return 1;
+	}
+	static int Polycode_Image_getHeight(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Image *inst = (Image*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getHeight());
+		return 1;
+	}
+	static int Polycode_Image_getPixels(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Image *inst = (Image*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getPixels();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Image_premultiplyAlpha(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Image *inst = (Image*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->premultiplyAlpha();
+		return 0;
+	}
+	static int Polycode_Image_savePNG(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Image *inst = (Image*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 2));
+		lua_pushboolean(L, inst->savePNG(fileName));
+		return 1;
+	}
+	static int Polycode_TouchInfo(lua_State *L) {
+		TouchInfo *inst = new TouchInfo();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.TouchInfo");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_InputEvent(lua_State *L) {
+		InputEvent *inst = new InputEvent();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.InputEvent");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_InputEvent_getMousePosition(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		InputEvent *inst = (InputEvent*) *((PolyBase**)lua_touserdata(L, 1));
+		Vector2 *retInst = new Vector2();
+		*retInst = inst->getMousePosition();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector2");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_InputEvent_getKey(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		InputEvent *inst = (InputEvent*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getKey());
+		return 1;
+	}
+	static int Polycode_InputEvent_getMouseButton(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		InputEvent *inst = (InputEvent*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getMouseButton());
+		return 1;
+	}
+	static int Polycode_InputEvent_getCharCode(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		InputEvent *inst = (InputEvent*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getCharCode());
+		return 1;
+	}
+	static int Polycode_InputEvent_keyCode(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		InputEvent *inst = (InputEvent*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->keyCode());
+		return 1;
+	}
+	static int Polycode_GlyphData(lua_State *L) {
+		GlyphData *inst = new GlyphData();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.GlyphData");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_GlyphData_clearData(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		GlyphData *inst = (GlyphData*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->clearData();
+		return 0;
+	}
+	static int Polycode_ColorRange(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Color color = *(Color*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int rangeStart = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int rangeEnd = lua_tointeger(L, 3);
+		ColorRange *inst = new ColorRange(color, rangeStart, rangeEnd);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.ColorRange");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Label(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Font* font = (Font*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String text = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int size = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int antiAliasMode = lua_tointeger(L, 4);
+		luaL_checktype(L, 5, LUA_TBOOLEAN);
+		bool premultiplyAlpha = lua_toboolean(L, 5) != 0;
+		luaL_checktype(L, 6, LUA_TUSERDATA);
+		Color backgroundColor = *(Color*) *((PolyBase**)lua_touserdata(L, 6));
+		luaL_checktype(L, 7, LUA_TUSERDATA);
+		Color foregroundColor = *(Color*) *((PolyBase**)lua_touserdata(L, 7));
+		Label *inst = new Label(font, text, size, antiAliasMode, premultiplyAlpha, backgroundColor, foregroundColor);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.Label");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Label_setText(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Label *inst = (Label*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String text = String(lua_tostring(L, 2));
+		inst->setText(text);
+		return 0;
+	}
+	static int Polycode_Label_getText(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Label *inst = (Label*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushstring(L, inst->getText().c_str());
+		return 1;
+	}
+	static int Polycode_Label_getTextWidthForString(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Label *inst = (Label*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String text = String(lua_tostring(L, 2));
+		lua_pushinteger(L, inst->getTextWidthForString(text));
+		return 1;
+	}
+	static int Polycode_Label_getTextHeightForString(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Label *inst = (Label*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String text = String(lua_tostring(L, 2));
+		lua_pushinteger(L, inst->getTextHeightForString(text));
+		return 1;
+	}
+	static int Polycode_Label_getTextWidth(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Label *inst = (Label*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getTextWidth());
+		return 1;
+	}
+	static int Polycode_Label_getTextHeight(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Label *inst = (Label*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getTextHeight());
+		return 1;
+	}
+	static int Polycode_Label_setColorForRange(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Label *inst = (Label*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Color color = *(Color*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int rangeStart = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int rangeEnd = lua_tointeger(L, 4);
+		inst->setColorForRange(color, rangeStart, rangeEnd);
+		return 0;
+	}
+	static int Polycode_Label_clearColors(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Label *inst = (Label*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->clearColors();
+		return 0;
+	}
+	static int Polycode_Label_getColorForIndex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Label *inst = (Label*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		Color *retInst = new Color();
+		*retInst = inst->getColorForIndex(index);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Color");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Label_getPremultiplyAlpha(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Label *inst = (Label*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->getPremultiplyAlpha());
+		return 1;
+	}
+	static int Polycode_Label_setPremultiplyAlpha(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Label *inst = (Label*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool val = lua_toboolean(L, 2) != 0;
+		inst->setPremultiplyAlpha(val);
+		return 0;
+	}
+	static int Polycode_Label_setFont(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Label *inst = (Label*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Font* newFont = (Font*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setFont(newFont);
+		return 0;
+	}
+	static int Polycode_Label_getFont(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Label *inst = (Label*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getFont();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Label_setSize(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Label *inst = (Label*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int newSize = lua_tointeger(L, 2);
+		inst->setSize(newSize);
+		return 0;
+	}
+	static int Polycode_Label_getSize(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Label *inst = (Label*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getSize());
+		return 1;
+	}
+	static int Polycode_Label_getAntialiasMode(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Label *inst = (Label*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getAntialiasMode());
+		return 1;
+	}
+	static int Polycode_Label_setAntialiasMode(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Label *inst = (Label*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int newMode = lua_tointeger(L, 2);
+		inst->setAntialiasMode(newMode);
+		return 0;
+	}
+	static int Polycode_Label_getBaselineAdjust(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Label *inst = (Label*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getBaselineAdjust());
+		return 1;
+	}
+	static int Polycode_Label_setBackgroundColor(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Label *inst = (Label*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Color color = *(Color*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setBackgroundColor(color);
+		return 0;
+	}
+	static int Polycode_Label_setForegroundColor(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Label *inst = (Label*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Color color = *(Color*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setForegroundColor(color);
+		return 0;
+	}
+	static int Polycode_Label_setColors(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Label *inst = (Label*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Color backgroundColor = *(Color*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Color foregroundColor = *(Color*) *((PolyBase**)lua_touserdata(L, 3));
+		inst->setColors(backgroundColor, foregroundColor);
+		return 0;
+	}
+	static int Polycode_Label_getBackgroundColor(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Label *inst = (Label*) *((PolyBase**)lua_touserdata(L, 1));
+		Color *retInst = new Color();
+		*retInst = inst->getBackgroundColor();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Color");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Label_getForegroundColor(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Label *inst = (Label*) *((PolyBase**)lua_touserdata(L, 1));
+		Color *retInst = new Color();
+		*retInst = inst->getForegroundColor();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Color");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Label_optionsChanged(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Label *inst = (Label*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->optionsChanged());
+		return 1;
+	}
+	static int Polycode_Material(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TSTRING);
+		String name = String(lua_tostring(L, 1));
+		Material *inst = new Material(name);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.Material");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Material_addShaderPass(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Material *inst = (Material*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ShaderPass pass = *(ShaderPass*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->addShaderPass(pass);
+		return 0;
+	}
+	static int Polycode_Material_addShaderPassAtIndex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Material *inst = (Material*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ShaderPass pass = *(ShaderPass*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int shaderIndex = lua_tointeger(L, 3);
+		inst->addShaderPassAtIndex(pass, shaderIndex);
+		return 0;
+	}
+	static int Polycode_Material_addShader(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Material *inst = (Material*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Shader* shader = (Shader*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		ShaderBinding* shaderBinding = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 3));
+		inst->addShader(shader, shaderBinding);
+		return 0;
+	}
+	static int Polycode_Material_addShaderAtIndex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Material *inst = (Material*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Shader* shader = (Shader*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		ShaderBinding* shaderBinding = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int shaderIndex = lua_tointeger(L, 4);
+		inst->addShaderAtIndex(shader, shaderBinding, shaderIndex);
+		return 0;
+	}
+	static int Polycode_Material_getNumShaderPasses(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Material *inst = (Material*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getNumShaderPasses());
+		return 1;
+	}
+	static int Polycode_Material_removeShaderPass(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Material *inst = (Material*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int shaderIndex = lua_tointeger(L, 2);
+		inst->removeShaderPass(shaderIndex);
+		return 0;
+	}
+	static int Polycode_Material_recreateExpectedShaderParams(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Material *inst = (Material*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->recreateExpectedShaderParams();
+		return 0;
+	}
+	static int Polycode_Material_addShaderRenderTarget(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Material *inst = (Material*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ShaderRenderTarget* newTarget = (ShaderRenderTarget*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->addShaderRenderTarget(newTarget);
+		return 0;
+	}
+	static int Polycode_Material_getNumShaderRenderTargets(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Material *inst = (Material*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getNumShaderRenderTargets());
+		return 1;
+	}
+	static int Polycode_Material_getShaderRenderTarget(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Material *inst = (Material*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->getShaderRenderTarget(index);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Material_removeShaderRenderTarget(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Material *inst = (Material*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		inst->removeShaderRenderTarget(index);
+		return 0;
+	}
+	static int Polycode_Material_recreateRenderTarget(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Material *inst = (Material*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ShaderRenderTarget* renderTarget = (ShaderRenderTarget*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->recreateRenderTarget(renderTarget);
+		return 0;
+	}
+	static int Polycode_Material_recreateRenderTargets(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Material *inst = (Material*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->recreateRenderTargets();
+		return 0;
+	}
+	static int Polycode_Material_getName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Material *inst = (Material*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushstring(L, inst->getName().c_str());
+		return 1;
+	}
+	static int Polycode_Material_getShaderPass(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Material *inst = (Material*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		ShaderPass *retInst = new ShaderPass();
+		*retInst = inst->getShaderPass(index);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.ShaderPass");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Material_getShaderBinding(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Material *inst = (Material*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->getShaderBinding(index);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Material_getShader(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Material *inst = (Material*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->getShader(index);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Material_loadMaterial(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Material *inst = (Material*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 2));
+		inst->loadMaterial(fileName);
+		return 0;
+	}
+	static int Polycode_Material_setName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Material *inst = (Material*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String name = String(lua_tostring(L, 2));
+		inst->setName(name);
+		return 0;
+	}
+	static int Polycode_Material_clearShaders(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Material *inst = (Material*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->clearShaders();
+		return 0;
+	}
+	static int Polycode_ShaderPass(lua_State *L) {
+		ShaderPass *inst = new ShaderPass();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.ShaderPass");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_ShaderPass_setAttributeArraysFromMesh(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderPass *inst = (ShaderPass*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Mesh* mesh = (Mesh*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setAttributeArraysFromMesh(mesh);
+		return 0;
+	}
+	static int Polycode_ShaderPass_setExpectedAttributes(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderPass *inst = (ShaderPass*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->setExpectedAttributes();
+		return 0;
+	}
+	static int Polycode_ShaderPass_arrayToAttributeName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderPass *inst = (ShaderPass*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		VertexDataArray* array = (VertexDataArray*) *((PolyBase**)lua_touserdata(L, 2));
+		lua_pushstring(L, inst->arrayToAttributeName(array).c_str());
+		return 1;
+	}
+	static int Polycode_MaterialManager(lua_State *L) {
+		MaterialManager *inst = new MaterialManager();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.MaterialManager");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_MaterialManager_Update(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		MaterialManager *inst = (MaterialManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int elapsed = lua_tointeger(L, 2);
+		inst->Update(elapsed);
+		return 0;
+	}
+	static int Polycode_MaterialManager_createTexture(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		MaterialManager *inst = (MaterialManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int width = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int height = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		char* imageData = (char*) *((PolyBase**)lua_touserdata(L, 4));
+		luaL_checktype(L, 5, LUA_TBOOLEAN);
+		bool clamp = lua_toboolean(L, 5) != 0;
+		luaL_checktype(L, 6, LUA_TBOOLEAN);
+		bool createMipmaps = lua_toboolean(L, 6) != 0;
+		luaL_checktype(L, 7, LUA_TNUMBER);
+		int type = lua_tointeger(L, 7);
+		PolyBase *ptrRetVal = (PolyBase*)inst->createTexture(width, height, imageData, clamp, createMipmaps, type);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_MaterialManager_createNewTexture(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		MaterialManager *inst = (MaterialManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int width = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int height = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TBOOLEAN);
+		bool clamp = lua_toboolean(L, 4) != 0;
+		luaL_checktype(L, 5, LUA_TBOOLEAN);
+		bool createMipmaps = lua_toboolean(L, 5) != 0;
+		luaL_checktype(L, 6, LUA_TNUMBER);
+		int type = lua_tointeger(L, 6);
+		PolyBase *ptrRetVal = (PolyBase*)inst->createNewTexture(width, height, clamp, createMipmaps, type);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_MaterialManager_createTextureFromImage(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		MaterialManager *inst = (MaterialManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Image* image = (Image*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool clamp = lua_toboolean(L, 3) != 0;
+		luaL_checktype(L, 4, LUA_TBOOLEAN);
+		bool createMipmaps = lua_toboolean(L, 4) != 0;
+		PolyBase *ptrRetVal = (PolyBase*)inst->createTextureFromImage(image, clamp, createMipmaps);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_MaterialManager_createTextureFromFile(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		MaterialManager *inst = (MaterialManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool clamp = lua_toboolean(L, 3) != 0;
+		luaL_checktype(L, 4, LUA_TBOOLEAN);
+		bool createMipmaps = lua_toboolean(L, 4) != 0;
+		luaL_checktype(L, 5, LUA_TUSERDATA);
+		ResourcePool* resourcePool = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 5));
+		PolyBase *ptrRetVal = (PolyBase*)inst->createTextureFromFile(fileName, clamp, createMipmaps, resourcePool);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_MaterialManager_deleteTexture(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		MaterialManager *inst = (MaterialManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Texture* texture = (Texture*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->deleteTexture(texture);
+		return 0;
+	}
+	static int Polycode_MaterialManager_reloadTextures(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		MaterialManager *inst = (MaterialManager*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->reloadTextures();
+		return 0;
+	}
+	static int Polycode_MaterialManager_reloadProgramsAndTextures(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		MaterialManager *inst = (MaterialManager*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->reloadProgramsAndTextures();
+		return 0;
+	}
+	static int Polycode_MaterialManager_reloadPrograms(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		MaterialManager *inst = (MaterialManager*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->reloadPrograms();
+		return 0;
+	}
+	static int Polycode_MaterialManager_getTextureByResourcePath(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		MaterialManager *inst = (MaterialManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String resourcePath = String(lua_tostring(L, 2));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getTextureByResourcePath(resourcePath);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_MaterialManager_createProgramFromFile(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		MaterialManager *inst = (MaterialManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String programPath = String(lua_tostring(L, 2));
+		PolyBase *ptrRetVal = (PolyBase*)inst->createProgramFromFile(programPath);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_MaterialManager_loadMaterialLibraryIntoPool(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		MaterialManager *inst = (MaterialManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ResourcePool* pool = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String materialFile = String(lua_tostring(L, 3));
+		inst->loadMaterialLibraryIntoPool(pool, materialFile);
+		return 0;
+	}
+	static int Polycode_MaterialManager_cubemapFromXMLNode(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		MaterialManager *inst = (MaterialManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		TiXmlNode* node = (TiXmlNode*) *((PolyBase**)lua_touserdata(L, 2));
+		PolyBase *ptrRetVal = (PolyBase*)inst->cubemapFromXMLNode(node);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_MaterialManager_materialFromXMLNode(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		MaterialManager *inst = (MaterialManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ResourcePool* resourcePool = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		TiXmlNode* node = (TiXmlNode*) *((PolyBase**)lua_touserdata(L, 3));
+		PolyBase *ptrRetVal = (PolyBase*)inst->materialFromXMLNode(resourcePool, node);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_MaterialManager_createMaterial(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		MaterialManager *inst = (MaterialManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ResourcePool* resourcePool = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String materialName = String(lua_tostring(L, 3));
+		luaL_checktype(L, 4, LUA_TSTRING);
+		String shaderName = String(lua_tostring(L, 4));
+		PolyBase *ptrRetVal = (PolyBase*)inst->createMaterial(resourcePool, materialName, shaderName);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_MaterialManager_setShaderFromXMLNode(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		MaterialManager *inst = (MaterialManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ResourcePool* resourcePool = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		TiXmlNode* node = (TiXmlNode*) *((PolyBase**)lua_touserdata(L, 3));
+		PolyBase *ptrRetVal = (PolyBase*)inst->setShaderFromXMLNode(resourcePool, node);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_MaterialManager_createShaderFromXMLNode(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		MaterialManager *inst = (MaterialManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ResourcePool* resourcePool = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		TiXmlNode* node = (TiXmlNode*) *((PolyBase**)lua_touserdata(L, 3));
+		PolyBase *ptrRetVal = (PolyBase*)inst->createShaderFromXMLNode(resourcePool, node);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_MaterialManager_createShader(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		MaterialManager *inst = (MaterialManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ResourcePool* resourcePool = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String shaderType = String(lua_tostring(L, 3));
+		luaL_checktype(L, 4, LUA_TSTRING);
+		String name = String(lua_tostring(L, 4));
+		luaL_checktype(L, 5, LUA_TSTRING);
+		String vpName = String(lua_tostring(L, 5));
+		luaL_checktype(L, 6, LUA_TSTRING);
+		String fpName = String(lua_tostring(L, 6));
+		luaL_checktype(L, 7, LUA_TBOOLEAN);
+		bool screenShader = lua_toboolean(L, 7) != 0;
+		PolyBase *ptrRetVal = (PolyBase*)inst->createShader(resourcePool, shaderType, name, vpName, fpName, screenShader);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_MaterialManager_loadMaterialsFromFile(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		MaterialManager *inst = (MaterialManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ResourcePool* resourcePool = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 3));
+	}
+	static int Polycode_MaterialManager_loadShadersFromFile(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		MaterialManager *inst = (MaterialManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ResourcePool* resourcePool = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 3));
+	}
+	static int Polycode_MaterialManager_loadCubemapsFromFile(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		MaterialManager *inst = (MaterialManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 2));
+	}
+	static int Polycode_MaterialManager_setAnisotropyAmount(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		MaterialManager *inst = (MaterialManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int anisotropy = lua_tointeger(L, 2);
+		inst->setAnisotropyAmount(anisotropy);
+		return 0;
+	}
+	static int Polycode_MaterialManager_setTextureFilteringMode(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		MaterialManager *inst = (MaterialManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int textureFilteringMode = lua_tointeger(L, 2);
+		inst->setTextureFilteringMode(textureFilteringMode);
+		return 0;
+	}
+	static int Polycode_MaterialManager_getTextureFilteringMode(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		MaterialManager *inst = (MaterialManager*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getTextureFilteringMode());
+		return 1;
+	}
+	static int Polycode_MaterialManager_addMaterial(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		MaterialManager *inst = (MaterialManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Material* material = (Material*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->addMaterial(material);
+		return 0;
+	}
+	static int Polycode_MaterialManager_addShader(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		MaterialManager *inst = (MaterialManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Shader* shader = (Shader*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->addShader(shader);
+		return 0;
+	}
+	static int Polycode_MaterialManager_getNumShaders(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		MaterialManager *inst = (MaterialManager*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getNumShaders());
+		return 1;
+	}
+	static int Polycode_MaterialManager_getShaderByIndex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		MaterialManager *inst = (MaterialManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->getShaderByIndex(index);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Matrix4(lua_State *L) {
+		Matrix4 *inst = new Matrix4();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.Matrix4");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Matrix4_identity(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Matrix4 *inst = (Matrix4*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->identity();
+		return 0;
+	}
+	static int Polycode_Matrix4_rotateVector(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Matrix4 *inst = (Matrix4*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 v2 = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->rotateVector(v2);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Matrix4_getPosition(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Matrix4 *inst = (Matrix4*) *((PolyBase**)lua_touserdata(L, 1));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->getPosition();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Matrix4_multiplyWithPerspective(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Matrix4 *inst = (Matrix4*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 v2 = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->multiplyWithPerspective(v2);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Matrix4_multVector3(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Matrix4 *inst = (Matrix4*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 v2 = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->multVector3(v2);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Matrix4_multVector4(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Matrix4 *inst = (Matrix4*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector4 v2 = *(Vector4*) *((PolyBase**)lua_touserdata(L, 2));
+		Vector4 *retInst = new Vector4();
+		*retInst = inst->multVector4(v2);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector4");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Matrix4_Translate(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Matrix4 *inst = (Matrix4*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number z = lua_tonumber(L, 4);
+		inst->Translate(x, y, z);
+		return 0;
+	}
+	static int Polycode_Matrix4_setPosition(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Matrix4 *inst = (Matrix4*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number z = lua_tonumber(L, 4);
+		inst->setPosition(x, y, z);
+		return 0;
+	}
+	static int Polycode_Matrix4_setScale(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Matrix4 *inst = (Matrix4*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 scale = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setScale(scale);
+		return 0;
+	}
+	static int Polycode_Matrix4_getEulerAngles(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Matrix4 *inst = (Matrix4*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Number* ax = (Number*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Number* ay = (Number*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		Number* az = (Number*) *((PolyBase**)lua_touserdata(L, 4));
+		inst->getEulerAngles(ax, ay, az);
+		return 0;
+	}
+	static int Polycode_Matrix4_transpose(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Matrix4 *inst = (Matrix4*) *((PolyBase**)lua_touserdata(L, 1));
+		Matrix4 *retInst = new Matrix4();
+		*retInst = inst->transpose();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Matrix4");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Matrix4_Inverse(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Matrix4 *inst = (Matrix4*) *((PolyBase**)lua_touserdata(L, 1));
+		Matrix4 *retInst = new Matrix4();
+		*retInst = inst->Inverse();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Matrix4");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Matrix4_inverseAffine(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Matrix4 *inst = (Matrix4*) *((PolyBase**)lua_touserdata(L, 1));
+		Matrix4 *retInst = new Matrix4();
+		*retInst = inst->inverseAffine();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Matrix4");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Matrix4_determinant(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Matrix4 *inst = (Matrix4*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->determinant());
+		return 1;
+	}
+	static int Polycode_Matrix4_generalDeterminant(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Matrix4 *inst = (Matrix4*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Number** a = (Number**) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int n = lua_tointeger(L, 3);
+		lua_pushnumber(L, inst->generalDeterminant(a, n));
+		return 1;
+	}
+	static int Polycode_Matrix4_setOrthoProjection(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Matrix4 *inst = (Matrix4*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number left = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number right = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number bottom = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number top = lua_tonumber(L, 5);
+		luaL_checktype(L, 6, LUA_TNUMBER);
+		Number zNear = lua_tonumber(L, 6);
+		luaL_checktype(L, 7, LUA_TNUMBER);
+		Number zFar = lua_tonumber(L, 7);
+		inst->setOrthoProjection(left, right, bottom, top, zNear, zFar);
+		return 0;
+	}
+	static int Polycode_Matrix4_setProjectionFrustum(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Matrix4 *inst = (Matrix4*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number left = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number right = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number bottom = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number top = lua_tonumber(L, 5);
+		luaL_checktype(L, 6, LUA_TNUMBER);
+		Number zNear = lua_tonumber(L, 6);
+		luaL_checktype(L, 7, LUA_TNUMBER);
+		Number zFar = lua_tonumber(L, 7);
+		inst->setProjectionFrustum(left, right, bottom, top, zNear, zFar);
+		return 0;
+	}
+	static int Polycode_Matrix4_setProjection(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Matrix4 *inst = (Matrix4*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number fov = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number aspect = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number zNear = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number zFar = lua_tonumber(L, 5);
+		inst->setProjection(fov, aspect, zNear, zFar);
+		return 0;
+	}
+	static int Polycode_Mesh(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TNUMBER);
+		int meshType = lua_tointeger(L, 1);
+		Mesh *inst = new Mesh(meshType);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.Mesh");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Mesh_MeshFromFileName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 2));
+		PolyBase *ptrRetVal = (PolyBase*)inst->MeshFromFileName(fileName);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Mesh_loadMesh(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 2));
+		inst->loadMesh(fileName);
+		return 0;
+	}
+	static int Polycode_Mesh_clearMesh(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->clearMesh();
+		return 0;
+	}
+	static int Polycode_Mesh_saveToFile(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool writeNormals = lua_toboolean(L, 3) != 0;
+		luaL_checktype(L, 4, LUA_TBOOLEAN);
+		bool writeTangents = lua_toboolean(L, 4) != 0;
+		luaL_checktype(L, 5, LUA_TBOOLEAN);
+		bool writeColors = lua_toboolean(L, 5) != 0;
+		luaL_checktype(L, 6, LUA_TBOOLEAN);
+		bool writeBoneWeights = lua_toboolean(L, 6) != 0;
+		luaL_checktype(L, 7, LUA_TBOOLEAN);
+		bool writeUVs = lua_toboolean(L, 7) != 0;
+		luaL_checktype(L, 8, LUA_TBOOLEAN);
+		bool writeSecondaryUVs = lua_toboolean(L, 8) != 0;
+		inst->saveToFile(fileName, writeNormals, writeTangents, writeColors, writeBoneWeights, writeUVs, writeSecondaryUVs);
+		return 0;
+	}
+	static int Polycode_Mesh_loadFromFile(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		CoreFile* inFile = (CoreFile*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->loadFromFile(inFile);
+		return 0;
+	}
+	static int Polycode_Mesh_getVertexCount(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getVertexCount());
+		return 1;
+	}
+	static int Polycode_Mesh_createPlane(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number w = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number h = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number tilingValue = lua_tonumber(L, 4);
+		inst->createPlane(w, h, tilingValue);
+		return 0;
+	}
+	static int Polycode_Mesh_createVPlane(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number w = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number h = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number tilingValue = lua_tonumber(L, 4);
+		inst->createVPlane(w, h, tilingValue);
+		return 0;
+	}
+	static int Polycode_Mesh_createCircle(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number w = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number h = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int numSegments = lua_tointeger(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number tilingValue = lua_tonumber(L, 5);
+		inst->createCircle(w, h, numSegments, tilingValue);
+		return 0;
+	}
+	static int Polycode_Mesh_createLineCircle(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number w = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number h = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int numSegments = lua_tointeger(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number tilingValue = lua_tonumber(L, 5);
+		inst->createLineCircle(w, h, numSegments, tilingValue);
+		return 0;
+	}
+	static int Polycode_Mesh_createTorus(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number radius = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number tubeRadius = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int segmentsW = lua_tointeger(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		int segmentsH = lua_tointeger(L, 5);
+		luaL_checktype(L, 6, LUA_TNUMBER);
+		Number tilingValue = lua_tonumber(L, 6);
+		inst->createTorus(radius, tubeRadius, segmentsW, segmentsH, tilingValue);
+		return 0;
+	}
+	static int Polycode_Mesh_createBox(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number w = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number d = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number h = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number tilingValue = lua_tonumber(L, 5);
+		inst->createBox(w, d, h, tilingValue);
+		return 0;
+	}
+	static int Polycode_Mesh_createSphere(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number radius = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int numRings = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int numSegments = lua_tointeger(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number tilingValue = lua_tonumber(L, 5);
+		inst->createSphere(radius, numRings, numSegments, tilingValue);
+		return 0;
+	}
+	static int Polycode_Mesh_createIcosphere(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number radius = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int subdivisions = lua_tointeger(L, 3);
+		inst->createIcosphere(radius, subdivisions);
+		return 0;
+	}
+	static int Polycode_Mesh_createOctosphere(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number radius = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int subdivisions = lua_tointeger(L, 3);
+		inst->createOctosphere(radius, subdivisions);
+		return 0;
+	}
+	static int Polycode_Mesh_createCylinder(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number height = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number radius = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int numSegments = lua_tointeger(L, 4);
+		luaL_checktype(L, 5, LUA_TBOOLEAN);
+		bool capped = lua_toboolean(L, 5) != 0;
+		luaL_checktype(L, 6, LUA_TNUMBER);
+		Number tilingValue = lua_tonumber(L, 6);
+		inst->createCylinder(height, radius, numSegments, capped, tilingValue);
+		return 0;
+	}
+	static int Polycode_Mesh_createCone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number height = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number radius = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int numSegments = lua_tointeger(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number tilingValue = lua_tonumber(L, 5);
+		inst->createCone(height, radius, numSegments, tilingValue);
+		return 0;
+	}
+	static int Polycode_Mesh_recenterMesh(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->recenterMesh();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Mesh_setVertexAtOffset(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int offset = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number z = lua_tonumber(L, 5);
+		inst->setVertexAtOffset(offset, x, y, z);
+		return 0;
+	}
+	static int Polycode_Mesh_addVertexWithUVAndNormal(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number z = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number u = lua_tonumber(L, 5);
+		luaL_checktype(L, 6, LUA_TNUMBER);
+		Number v = lua_tonumber(L, 6);
+		luaL_checktype(L, 7, LUA_TNUMBER);
+		Number nx = lua_tonumber(L, 7);
+		luaL_checktype(L, 8, LUA_TNUMBER);
+		Number ny = lua_tonumber(L, 8);
+		luaL_checktype(L, 9, LUA_TNUMBER);
+		Number nz = lua_tonumber(L, 9);
+		inst->addVertexWithUVAndNormal(x, y, z, u, v, nx, ny, nz);
+		return 0;
+	}
+	static int Polycode_Mesh_addTexCoord(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number u = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number v = lua_tonumber(L, 3);
+		inst->addTexCoord(u, v);
+		return 0;
+	}
+	static int Polycode_Mesh_addTexCoord2(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number u = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number v = lua_tonumber(L, 3);
+		inst->addTexCoord2(u, v);
+		return 0;
+	}
+	static int Polycode_Mesh_addTangent(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number z = lua_tonumber(L, 4);
+		inst->addTangent(x, y, z);
+		return 0;
+	}
+	static int Polycode_Mesh_addVertexWithUV(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number z = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number u = lua_tonumber(L, 5);
+		luaL_checktype(L, 6, LUA_TNUMBER);
+		Number v = lua_tonumber(L, 6);
+		inst->addVertexWithUV(x, y, z, u, v);
+		return 0;
+	}
+	static int Polycode_Mesh_addVertex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number z = lua_tonumber(L, 4);
+		inst->addVertex(x, y, z);
+		return 0;
+	}
+	static int Polycode_Mesh_addNormal(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number nx = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number ny = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number nz = lua_tonumber(L, 4);
+		inst->addNormal(nx, ny, nz);
+		return 0;
+	}
+	static int Polycode_Mesh_addBoneAssignments(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number b1Weight = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int b1Index = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number b2Weight = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		int b2Index = lua_tointeger(L, 5);
+		luaL_checktype(L, 6, LUA_TNUMBER);
+		Number b3Weight = lua_tonumber(L, 6);
+		luaL_checktype(L, 7, LUA_TNUMBER);
+		int b3Index = lua_tointeger(L, 7);
+		luaL_checktype(L, 8, LUA_TNUMBER);
+		Number b4Weight = lua_tonumber(L, 8);
+		luaL_checktype(L, 9, LUA_TNUMBER);
+		int b4Index = lua_tointeger(L, 9);
+		inst->addBoneAssignments(b1Weight, b1Index, b2Weight, b2Index, b3Weight, b3Index, b4Weight, b4Index);
+		return 0;
+	}
+	static int Polycode_Mesh_addColor(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number r = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number g = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number b = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number a = lua_tonumber(L, 5);
+		inst->addColor(r, g, b, a);
+		return 0;
+	}
+	static int Polycode_Mesh_getVertexPosition(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int vertexOffset = lua_tointeger(L, 2);
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->getVertexPosition(vertexOffset);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Mesh_getVertexPositionAtIndex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->getVertexPositionAtIndex(index);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Mesh_getVertexTexCoord(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int vertexOffset = lua_tointeger(L, 2);
+		Vector2 *retInst = new Vector2();
+		*retInst = inst->getVertexTexCoord(vertexOffset);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector2");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Mesh_getVertexTexCoordAtIndex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		Vector2 *retInst = new Vector2();
+		*retInst = inst->getVertexTexCoordAtIndex(index);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector2");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Mesh_Copy(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->Copy();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Mesh_getRadius(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getRadius());
+		return 1;
+	}
+	static int Polycode_Mesh_calculateNormals(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->calculateNormals();
+		return 0;
+	}
+	static int Polycode_Mesh_calculateTangents(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->calculateTangents();
+		return 0;
+	}
+	static int Polycode_Mesh_getMeshType(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getMeshType());
+		return 1;
+	}
+	static int Polycode_Mesh_setMeshType(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int newType = lua_tointeger(L, 2);
+		inst->setMeshType(newType);
+		return 0;
+	}
+	static int Polycode_Mesh_getIndexGroupSize(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getIndexGroupSize());
+		return 1;
+	}
+	static int Polycode_Mesh_calculateBBox(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->calculateBBox();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Mesh_hasVertexBuffer(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->hasVertexBuffer());
+		return 1;
+	}
+	static int Polycode_Mesh_addIndexedFace(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int i1 = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int i2 = lua_tointeger(L, 3);
+		inst->addIndexedFace(i1, i2);
+		return 0;
+	}
+	static int Polycode_Mesh_addIndex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		inst->addIndex(index);
+		return 0;
+	}
+	static int Polycode_Mesh_removeVertexRange(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int beginRemoveVertex = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int vertexRemovalCount = lua_tointeger(L, 3);
+		inst->removeVertexRange(beginRemoveVertex, vertexRemovalCount);
+		return 0;
+	}
+	static int Polycode_Mesh_removeFace(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int faceIndex = lua_tointeger(L, 2);
+		inst->removeFace(faceIndex);
+		return 0;
+	}
+	static int Polycode_Mesh_removeUnusedVertices(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->removeUnusedVertices());
+		return 1;
+	}
+	static int Polycode_Mesh_getIndexCount(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getIndexCount());
+		return 1;
+	}
+	static int Polycode_Mesh_subdivideToRadius(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number radius = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int subdivisions = lua_tointeger(L, 3);
+		inst->subdivideToRadius(radius, subdivisions);
+		return 0;
+	}
+	static int Polycode_Mesh_calculateFaceTangent(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 v1 = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Vector3 v2 = *(Vector3*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		Vector3 v3 = *(Vector3*) *((PolyBase**)lua_touserdata(L, 4));
+		luaL_checktype(L, 5, LUA_TUSERDATA);
+		Vector2 texCoord1 = *(Vector2*) *((PolyBase**)lua_touserdata(L, 5));
+		luaL_checktype(L, 6, LUA_TUSERDATA);
+		Vector2 texCoord2 = *(Vector2*) *((PolyBase**)lua_touserdata(L, 6));
+		luaL_checktype(L, 7, LUA_TUSERDATA);
+		Vector2 texCoord3 = *(Vector2*) *((PolyBase**)lua_touserdata(L, 7));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->calculateFaceTangent(v1, v2, v3, texCoord1, texCoord2, texCoord3);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Mesh_saveAsOBJ(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 2));
+		inst->saveAsOBJ(fileName);
+		return 0;
+	}
+	static int Polycode_Mesh_normalizeBoneWeights(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Mesh *inst = (Mesh*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->normalizeBoneWeights();
+		return 0;
+	}
+	static int Polycode_ObjectEntry(lua_State *L) {
+		ObjectEntry *inst = new ObjectEntry();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.ObjectEntry");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_ObjectEntry_readNumber(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ObjectEntry *inst = (ObjectEntry*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String key = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Number* out = (Number*) *((PolyBase**)lua_touserdata(L, 3));
+		lua_pushboolean(L, inst->readNumber(key, out));
+		return 1;
+	}
+	static int Polycode_ObjectEntry_readString(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ObjectEntry *inst = (ObjectEntry*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String key = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		String* out = (String*) *((PolyBase**)lua_touserdata(L, 3));
+		lua_pushboolean(L, inst->readString(key, out));
+		return 1;
+	}
+	static int Polycode_ObjectEntry_readBool(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ObjectEntry *inst = (ObjectEntry*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String key = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		bool* out = (bool*) *((PolyBase**)lua_touserdata(L, 3));
+		lua_pushboolean(L, inst->readBool(key, out));
+		return 1;
+	}
+	static int Polycode_ObjectEntry_addChild(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ObjectEntry *inst = (ObjectEntry*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String name = String(lua_tostring(L, 2));
+		PolyBase *ptrRetVal = (PolyBase*)inst->addChild(name);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_ObjectEntry_getTypedName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ObjectEntry *inst = (ObjectEntry*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushstring(L, inst->getTypedName().c_str());
+		return 1;
+	}
+	static int Polycode_ObjectEntry_setTypedName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ObjectEntry *inst = (ObjectEntry*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String str = String(lua_tostring(L, 2));
+		inst->setTypedName(str);
+		return 0;
+	}
+	static int Polycode_ObjectEntry_Clear(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ObjectEntry *inst = (ObjectEntry*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->Clear();
+		return 0;
+	}
+	static int Polycode_BinaryObjectReader(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Object* object = (Object*) *((PolyBase**)lua_touserdata(L, 2));
+		BinaryObjectReader *inst = new BinaryObjectReader(fileName, object);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.BinaryObjectReader");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_BinaryObjectWriter(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Object* object = (Object*) *((PolyBase**)lua_touserdata(L, 1));
+		BinaryObjectWriter *inst = new BinaryObjectWriter(object);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.BinaryObjectWriter");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_BinaryObjectWriter_parseKeysFromObjectEntry(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BinaryObjectWriter *inst = (BinaryObjectWriter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ObjectEntry* entry = (ObjectEntry*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->parseKeysFromObjectEntry(entry);
+		return 0;
+	}
+	static int Polycode_BinaryObjectWriter_writeEntryToFile(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BinaryObjectWriter *inst = (BinaryObjectWriter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ObjectEntry* entry = (ObjectEntry*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->writeEntryToFile(entry);
+		return 0;
+	}
+	static int Polycode_BinaryObjectWriter_addKey(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BinaryObjectWriter *inst = (BinaryObjectWriter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String key = String(lua_tostring(L, 2));
+		lua_pushinteger(L, inst->addKey(key));
+		return 1;
+	}
+	static int Polycode_BinaryObjectWriter_getKeyIndex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BinaryObjectWriter *inst = (BinaryObjectWriter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String key = String(lua_tostring(L, 2));
+		lua_pushinteger(L, inst->getKeyIndex(key));
+		return 1;
+	}
+	static int Polycode_BinaryObjectWriter_writeToFile(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BinaryObjectWriter *inst = (BinaryObjectWriter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 2));
+		lua_pushboolean(L, inst->writeToFile(fileName));
+		return 1;
+	}
+	static int Polycode_OpenGLGraphicsInterface(lua_State *L) {
+		OpenGLGraphicsInterface *inst = new OpenGLGraphicsInterface();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.OpenGLGraphicsInterface");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_OpenGLGraphicsInterface_createTexture(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Texture* texture = (Texture*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->createTexture(texture);
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_destroyTexture(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Texture* texture = (Texture*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->destroyTexture(texture);
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_setViewport(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int x = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int y = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int width = lua_tointeger(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		int height = lua_tointeger(L, 5);
+		inst->setViewport(x, y, width, height);
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_clearBuffers(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Color clearColor = *(Color*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool colorBuffer = lua_toboolean(L, 3) != 0;
+		luaL_checktype(L, 4, LUA_TBOOLEAN);
+		bool depthBuffer = lua_toboolean(L, 4) != 0;
+		luaL_checktype(L, 5, LUA_TBOOLEAN);
+		bool stencilBuffer = lua_toboolean(L, 5) != 0;
+		inst->clearBuffers(clearColor, colorBuffer, depthBuffer, stencilBuffer);
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_setParamInShader(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Shader* shader = (Shader*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		ProgramParam* param = (ProgramParam*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		LocalShaderParam* localParam = (LocalShaderParam*) *((PolyBase**)lua_touserdata(L, 4));
+		inst->setParamInShader(shader, param, localParam);
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_setAttributeInShader(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Shader* shader = (Shader*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		ProgramAttribute* attribute = (ProgramAttribute*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		AttributeBinding* attributeBinding = (AttributeBinding*) *((PolyBase**)lua_touserdata(L, 4));
+		inst->setAttributeInShader(shader, attribute, attributeBinding);
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_disableAttribute(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Shader* shader = (Shader*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		ProgramAttribute attribute = *(ProgramAttribute*) *((PolyBase**)lua_touserdata(L, 3));
+		inst->disableAttribute(shader, attribute);
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_useShader(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Shader* shader = (Shader*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->useShader(shader);
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_createProgram(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ShaderProgram* program = (ShaderProgram*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->createProgram(program);
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_destroyProgram(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ShaderProgram* program = (ShaderProgram*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->destroyProgram(program);
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_createVBOForVertexArray(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		VertexDataArray* array = (VertexDataArray*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->createVBOForVertexArray(array);
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_createMesh(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Mesh* mesh = (Mesh*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->createMesh(mesh);
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_destroyMesh(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Mesh* mesh = (Mesh*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->destroyMesh(mesh);
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_createShader(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Shader* shader = (Shader*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->createShader(shader);
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_destroyShader(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Shader* shader = (Shader*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->destroyShader(shader);
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_beginDrawCall(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->beginDrawCall();
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_endDrawCall(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->endDrawCall();
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_setBlendingMode(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int blendingMode = lua_tointeger(L, 2);
+		inst->setBlendingMode(blendingMode);
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_createRenderBuffer(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		RenderBuffer* renderBuffer = (RenderBuffer*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->createRenderBuffer(renderBuffer);
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_destroyRenderBuffer(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		RenderBuffer* renderBuffer = (RenderBuffer*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->destroyRenderBuffer(renderBuffer);
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_bindRenderBuffer(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		RenderBuffer* renderBuffer = (RenderBuffer*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->bindRenderBuffer(renderBuffer);
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_createVertexBuffer(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		VertexDataArray* dataArray = (VertexDataArray*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->createVertexBuffer(dataArray);
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_createIndexBuffer(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		IndexDataArray* dataArray = (IndexDataArray*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->createIndexBuffer(dataArray);
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_destroyBuffer(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		RenderDataArray* array = (RenderDataArray*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->destroyBuffer(array);
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_drawIndices(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int type = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		IndexDataArray* indexArray = (IndexDataArray*) *((PolyBase**)lua_touserdata(L, 3));
+		inst->drawIndices(type, indexArray);
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_drawArrays(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int type = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int vertexCount = lua_tointeger(L, 3);
+		inst->drawArrays(type, vertexCount);
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_enableDepthTest(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool val = lua_toboolean(L, 2) != 0;
+		inst->enableDepthTest(val);
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_enableDepthWrite(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool val = lua_toboolean(L, 2) != 0;
+		inst->enableDepthWrite(val);
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_enableBackfaceCulling(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool val = lua_toboolean(L, 2) != 0;
+		inst->enableBackfaceCulling(val);
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_setLineSize(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number lineSize = lua_tonumber(L, 2);
+		inst->setLineSize(lineSize);
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_setWireframeMode(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool val = lua_toboolean(L, 2) != 0;
+		inst->setWireframeMode(val);
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_enableScissor(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool val = lua_toboolean(L, 2) != 0;
+		inst->enableScissor(val);
+		return 0;
+	}
+	static int Polycode_OpenGLGraphicsInterface_setScissorBox(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		OpenGLGraphicsInterface *inst = (OpenGLGraphicsInterface*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Polycode::Rectangle box = *(Polycode::Rectangle*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setScissorBox(box);
+		return 0;
+	}
+	static int Polycode_SceneParticleEmitter(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TNUMBER);
+		int particleCount = lua_tointeger(L, 1);
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number lifetime = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number speed = lua_tonumber(L, 3);
+		SceneParticleEmitter *inst = new SceneParticleEmitter(particleCount, lifetime, speed);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.SceneParticleEmitter");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_SceneParticleEmitter_setParticleCount(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int newParticleCount = lua_tointeger(L, 2);
+		inst->setParticleCount(newParticleCount);
+		return 0;
+	}
+	static int Polycode_SceneParticleEmitter_getParticleCount(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getParticleCount());
+		return 1;
+	}
+	static int Polycode_SceneParticleEmitter_setParticleLifetime(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number lifetime = lua_tonumber(L, 2);
+		inst->setParticleLifetime(lifetime);
+		return 0;
+	}
+	static int Polycode_SceneParticleEmitter_getParticleLifetime(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getParticleLifetime());
+		return 1;
+	}
+	static int Polycode_SceneParticleEmitter_setDirectionDeviation(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 newDeviation = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setDirectionDeviation(newDeviation);
+		return 0;
+	}
+	static int Polycode_SceneParticleEmitter_getDirectionDeviation(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->getDirectionDeviation();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_SceneParticleEmitter_setEmitterSize(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 newSize = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setEmitterSize(newSize);
+		return 0;
+	}
+	static int Polycode_SceneParticleEmitter_getEmitterSize(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->getEmitterSize();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_SceneParticleEmitter_setGravity(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 newGravity = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setGravity(newGravity);
+		return 0;
+	}
+	static int Polycode_SceneParticleEmitter_getGravity(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->getGravity();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_SceneParticleEmitter_fixedUpdate(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->fixedUpdate();
+		return 0;
+	}
+	static int Polycode_SceneParticleEmitter_Render(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		GPUDrawBuffer* buffer = (GPUDrawBuffer*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->Render(buffer);
+		return 0;
+	}
+	static int Polycode_SceneParticleEmitter_updateParticles(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->updateParticles();
+		return 0;
+	}
+	static int Polycode_SceneParticleEmitter_rebuildParticles(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		GPUDrawBuffer* buffer = (GPUDrawBuffer*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->rebuildParticles(buffer);
+		return 0;
+	}
+	static int Polycode_SceneParticleEmitter_triggerParticles(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool allAtOnce = lua_toboolean(L, 2) != 0;
+		inst->triggerParticles(allAtOnce);
+		return 0;
+	}
+	static int Polycode_SceneParticleEmitter_enableParticleSystem(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool val = lua_toboolean(L, 2) != 0;
+		inst->enableParticleSystem(val);
+		return 0;
+	}
+	static int Polycode_SceneParticleEmitter_setUseFloorPlane(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool val = lua_toboolean(L, 2) != 0;
+		inst->setUseFloorPlane(val);
+		return 0;
+	}
+	static int Polycode_SceneParticleEmitter_setFloorPlaneOffset(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number floorPlaneOffset = lua_tonumber(L, 2);
+		inst->setFloorPlaneOffset(floorPlaneOffset);
+		return 0;
+	}
+	static int Polycode_SceneParticleEmitter_setFloorDamping(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number floorDamping = lua_tonumber(L, 2);
+		inst->setFloorDamping(floorDamping);
+		return 0;
+	}
+	static int Polycode_SceneParticleEmitter_setParticlesInWorldSpace(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool val = lua_toboolean(L, 2) != 0;
+		inst->setParticlesInWorldSpace(val);
+		return 0;
+	}
+	static int Polycode_SceneParticleEmitter_getParticlesInWorldSpace(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->getParticlesInWorldSpace());
+		return 1;
+	}
+	static int Polycode_SceneParticleEmitter_setPerlinEnabled(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool val = lua_toboolean(L, 2) != 0;
+		inst->setPerlinEnabled(val);
+		return 0;
+	}
+	static int Polycode_SceneParticleEmitter_getPerlinEnabled(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->getPerlinEnabled());
+		return 1;
+	}
+	static int Polycode_SceneParticleEmitter_getParticleSpeed(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getParticleSpeed());
+		return 1;
+	}
+	static int Polycode_SceneParticleEmitter_setParticleSpeed(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number speed = lua_tonumber(L, 2);
+		inst->setParticleSpeed(speed);
+		return 0;
+	}
+	static int Polycode_SceneParticleEmitter_setPerlinValue(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 perlinValue = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setPerlinValue(perlinValue);
+		return 0;
+	}
+	static int Polycode_SceneParticleEmitter_getPerlinValue(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->getPerlinValue();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_SceneParticleEmitter_setParticleType(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int particleType = lua_tointeger(L, 2);
+		inst->setParticleType(particleType);
+		return 0;
+	}
+	static int Polycode_SceneParticleEmitter_getParticleType(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getParticleType());
+		return 1;
+	}
+	static int Polycode_SceneParticleEmitter_setParticleSize(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number particleSize = lua_tonumber(L, 2);
+		inst->setParticleSize(particleSize);
+		return 0;
+	}
+	static int Polycode_SceneParticleEmitter_getParticleSize(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getParticleSize());
+		return 1;
+	}
+	static int Polycode_SceneParticleEmitter_setParticleRotationSpeed(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 rotationSpeed = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setParticleRotationSpeed(rotationSpeed);
+		return 0;
+	}
+	static int Polycode_SceneParticleEmitter_getParticleRotationSpeed(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->getParticleRotationSpeed();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_SceneParticleEmitter_setParticleDirection(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 direction = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setParticleDirection(direction);
+		return 0;
+	}
+	static int Polycode_SceneParticleEmitter_getParticleDirection(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->getParticleDirection();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_SceneParticleEmitter_setLoopParticles(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool val = lua_toboolean(L, 2) != 0;
+		inst->setLoopParticles(val);
+		return 0;
+	}
+	static int Polycode_SceneParticleEmitter_getLoopParticles(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->getLoopParticles());
+		return 1;
+	}
+	static int Polycode_SceneParticleEmitter_addSourceMesh(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Mesh* mesh = (Mesh*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->addSourceMesh(mesh);
+		return 0;
+	}
+	static int Polycode_SceneParticleEmitter_getNumSourceMeshes(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getNumSourceMeshes());
+		return 1;
+	}
+	static int Polycode_SceneParticleEmitter_getSourcesMeshAtIndex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->getSourcesMeshAtIndex(index);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneParticleEmitter_removeSourceMeshAtIndex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		inst->removeSourceMeshAtIndex(index);
+		return 0;
+	}
+	static int Polycode_SceneParticleEmitter_positionParticle(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		inst->positionParticle(index);
+		return 0;
+	}
+	static int Polycode_SceneParticleEmitter_Clone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool deepClone = lua_toboolean(L, 2) != 0;
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool ignoreEditorOnly = lua_toboolean(L, 3) != 0;
+		PolyBase *ptrRetVal = (PolyBase*)inst->Clone(deepClone, ignoreEditorOnly);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneParticleEmitter_applyClone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneParticleEmitter *inst = (SceneParticleEmitter*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Entity* clone = (Entity*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool deepClone = lua_toboolean(L, 3) != 0;
+		luaL_checktype(L, 4, LUA_TBOOLEAN);
+		bool ignoreEditorOnly = lua_toboolean(L, 4) != 0;
+		inst->applyClone(clone, deepClone, ignoreEditorOnly);
+		return 0;
+	}
+	static int Polycode_Perlin(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TNUMBER);
+		int octaves = lua_tointeger(L, 1);
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number freq = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number amp = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int seed = lua_tointeger(L, 4);
+		Perlin *inst = new Perlin(octaves, freq, amp, seed);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.Perlin");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Perlin_Get2DTiledX(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Perlin *inst = (Perlin*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number t = lua_tonumber(L, 4);
+		lua_pushnumber(L, inst->Get2DTiledX(x, y, t));
+		return 1;
+	}
+	static int Polycode_Perlin_Get(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Perlin *inst = (Perlin*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 3);
+		lua_pushnumber(L, inst->Get(x, y));
+		return 1;
+	}
+	static int Polycode_Perlin_Get2D(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Perlin *inst = (Perlin*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 3);
+		lua_pushnumber(L, inst->Get2D(x, y));
+		return 1;
+	}
+	static int Polycode_Perlin_Get3D(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Perlin *inst = (Perlin*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number z = lua_tonumber(L, 4);
+		lua_pushnumber(L, inst->Get3D(x, y, z));
+		return 1;
+	}
+	static int Polycode_PhysFSFile_read(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		PhysFSFile *inst = (PhysFSFile*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		void* ptr = (void*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		size_t size = *(size_t*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		size_t count = *(size_t*) *((PolyBase**)lua_touserdata(L, 4));
+		lua_pushinteger(L, inst->read(ptr, size, count));
+		return 1;
+	}
+	static int Polycode_PhysFSFile_write(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		PhysFSFile *inst = (PhysFSFile*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		void* ptr = (void*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		size_t size = *(size_t*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		size_t count = *(size_t*) *((PolyBase**)lua_touserdata(L, 4));
+		lua_pushinteger(L, inst->write(ptr, size, count));
+		return 1;
+	}
+	static int Polycode_PhysFSFile_seek(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		PhysFSFile *inst = (PhysFSFile*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int offset = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int origin = lua_tointeger(L, 3);
+		lua_pushinteger(L, inst->seek(offset, origin));
+		return 1;
+	}
+	static int Polycode_PhysFSFile_tell(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		PhysFSFile *inst = (PhysFSFile*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->tell());
+		return 1;
+	}
+	static int Polycode_PhysFSFileProvider(lua_State *L) {
+		PhysFSFileProvider *inst = new PhysFSFileProvider();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.PhysFSFileProvider");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_PhysFSFileProvider_openFile(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		PhysFSFileProvider *inst = (PhysFSFileProvider*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String opts = String(lua_tostring(L, 3));
+		PolyBase *ptrRetVal = (PolyBase*)inst->openFile(fileName, opts);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_PhysFSFileProvider_closeFile(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		PhysFSFileProvider *inst = (PhysFSFileProvider*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		CoreFile* file = (CoreFile*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->closeFile(file);
+		return 0;
+	}
+	static int Polycode_PhysFSFileProvider_parseFolder(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		PhysFSFileProvider *inst = (PhysFSFileProvider*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String pathString = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool showHidden = lua_toboolean(L, 3) != 0;
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		vector<OSFileEntry> targetVector = *(vector<OSFileEntry>*) *((PolyBase**)lua_touserdata(L, 4));
+		lua_pushboolean(L, inst->parseFolder(pathString, showHidden, targetVector));
+		return 1;
+	}
+	static int Polycode_PhysFSFileProvider_addSource(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		PhysFSFileProvider *inst = (PhysFSFileProvider*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String source = String(lua_tostring(L, 2));
+		inst->addSource(source);
+		return 0;
+	}
+	static int Polycode_PhysFSFileProvider_removeSource(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		PhysFSFileProvider *inst = (PhysFSFileProvider*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String source = String(lua_tostring(L, 2));
+		inst->removeSource(source);
+		return 0;
+	}
+	static int Polycode_Quaternion(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TNUMBER);
+		Number w = lua_tonumber(L, 1);
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number z = lua_tonumber(L, 4);
+		Quaternion *inst = new Quaternion(w, x, y, z);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.Quaternion");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Quaternion_setFromMatrix(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Quaternion *inst = (Quaternion*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Matrix4 _mat = *(Matrix4*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setFromMatrix(_mat);
+		return 0;
+	}
+	static int Polycode_Quaternion_Slerp(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Quaternion *inst = (Quaternion*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number fT = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Quaternion rkP = *(Quaternion*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		Quaternion rkQ = *(Quaternion*) *((PolyBase**)lua_touserdata(L, 4));
+		luaL_checktype(L, 5, LUA_TBOOLEAN);
+		bool shortestPath = lua_toboolean(L, 5) != 0;
+		Quaternion *retInst = new Quaternion();
+		*retInst = inst->Slerp(fT, rkP, rkQ, shortestPath);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Quaternion");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Quaternion_Dot(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Quaternion *inst = (Quaternion*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Quaternion rkQ = *(Quaternion*) *((PolyBase**)lua_touserdata(L, 2));
+		lua_pushnumber(L, inst->Dot(rkQ));
+		return 1;
+	}
+	static int Polycode_Quaternion_Log(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Quaternion *inst = (Quaternion*) *((PolyBase**)lua_touserdata(L, 1));
+		Quaternion *retInst = new Quaternion();
+		*retInst = inst->Log();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Quaternion");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Quaternion_Exp(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Quaternion *inst = (Quaternion*) *((PolyBase**)lua_touserdata(L, 1));
+		Quaternion *retInst = new Quaternion();
+		*retInst = inst->Exp();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Quaternion");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Quaternion_Norm(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Quaternion *inst = (Quaternion*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->Norm());
+		return 1;
+	}
+	static int Polycode_Quaternion_Normalize(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Quaternion *inst = (Quaternion*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->Normalize());
+		return 1;
+	}
+	static int Polycode_Quaternion_lookAt(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Quaternion *inst = (Quaternion*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 D = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Vector3 upVector = *(Vector3*) *((PolyBase**)lua_touserdata(L, 3));
+		inst->lookAt(D, upVector);
+		return 0;
+	}
+	static int Polycode_Quaternion_createFromMatrix(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Quaternion *inst = (Quaternion*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Matrix4 matrix = *(Matrix4*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->createFromMatrix(matrix);
+		return 0;
+	}
+	static int Polycode_Quaternion_Squad(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Quaternion *inst = (Quaternion*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number fT = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Quaternion rkP = *(Quaternion*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		Quaternion rkA = *(Quaternion*) *((PolyBase**)lua_touserdata(L, 4));
+		luaL_checktype(L, 5, LUA_TUSERDATA);
+		Quaternion rkB = *(Quaternion*) *((PolyBase**)lua_touserdata(L, 5));
+		luaL_checktype(L, 6, LUA_TUSERDATA);
+		Quaternion rkQ = *(Quaternion*) *((PolyBase**)lua_touserdata(L, 6));
+		luaL_checktype(L, 7, LUA_TBOOLEAN);
+		bool shortestPath = lua_toboolean(L, 7) != 0;
+		Quaternion *retInst = new Quaternion();
+		*retInst = inst->Squad(fT, rkP, rkA, rkB, rkQ, shortestPath);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Quaternion");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Quaternion_Inverse(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Quaternion *inst = (Quaternion*) *((PolyBase**)lua_touserdata(L, 1));
+		Quaternion *retInst = new Quaternion();
+		*retInst = inst->Inverse();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Quaternion");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Quaternion_set(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Quaternion *inst = (Quaternion*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number w = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number z = lua_tonumber(L, 5);
+		inst->set(w, x, y, z);
+		return 0;
+	}
+	static int Polycode_Quaternion_InvSqrt(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Quaternion *inst = (Quaternion*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 2);
+		lua_pushnumber(L, inst->InvSqrt(x));
+		return 1;
+	}
+	static int Polycode_Quaternion_fromAxes(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Quaternion *inst = (Quaternion*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number az = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number ay = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number ax = lua_tonumber(L, 4);
+		inst->fromAxes(az, ay, ax);
+		return 0;
+	}
+	static int Polycode_Quaternion_fromAngleAxis(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Quaternion *inst = (Quaternion*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number rfAngle = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Vector3 rkAxis = *(Vector3*) *((PolyBase**)lua_touserdata(L, 3));
+		inst->fromAngleAxis(rfAngle, rkAxis);
+		return 0;
+	}
+	static int Polycode_Quaternion_toEulerAngles(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Quaternion *inst = (Quaternion*) *((PolyBase**)lua_touserdata(L, 1));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->toEulerAngles();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Quaternion_toAngleAxis(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Quaternion *inst = (Quaternion*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number rfAngle = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Vector3 rkAxis = *(Vector3*) *((PolyBase**)lua_touserdata(L, 3));
+		inst->toAngleAxis(rfAngle, rkAxis);
+		return 0;
+	}
+	static int Polycode_Quaternion_createFromAxisAngle(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Quaternion *inst = (Quaternion*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number z = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number degrees = lua_tonumber(L, 5);
+		inst->createFromAxisAngle(x, y, z, degrees);
+		return 0;
+	}
+	static int Polycode_Quaternion_createMatrix(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Quaternion *inst = (Quaternion*) *((PolyBase**)lua_touserdata(L, 1));
+		Matrix4 *retInst = new Matrix4();
+		*retInst = inst->createMatrix();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Matrix4");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Quaternion_applyTo(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Quaternion *inst = (Quaternion*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 v = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->applyTo(v);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_QuaternionCurve(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BezierCurve* wCurve = (BezierCurve*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		BezierCurve* xCurve = (BezierCurve*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		BezierCurve* yCurve = (BezierCurve*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		BezierCurve* zCurve = (BezierCurve*) *((PolyBase**)lua_touserdata(L, 4));
+		QuaternionCurve *inst = new QuaternionCurve(wCurve, xCurve, yCurve, zCurve);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.QuaternionCurve");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_QuaternionCurve_interpolate(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		QuaternionCurve *inst = (QuaternionCurve*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number t = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool useShortestPath = lua_toboolean(L, 3) != 0;
+		Quaternion *retInst = new Quaternion();
+		*retInst = inst->interpolate(t, useShortestPath);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Quaternion");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_QuaternionCurve_generatePointsFromCurves(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		QuaternionCurve *inst = (QuaternionCurve*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		BezierCurve* wCurve = (BezierCurve*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		BezierCurve* xCurve = (BezierCurve*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		BezierCurve* yCurve = (BezierCurve*) *((PolyBase**)lua_touserdata(L, 4));
+		luaL_checktype(L, 5, LUA_TUSERDATA);
+		BezierCurve* zCurve = (BezierCurve*) *((PolyBase**)lua_touserdata(L, 5));
+		inst->generatePointsFromCurves(wCurve, xCurve, yCurve, zCurve);
+		return 0;
+	}
+	static int Polycode_Ray(lua_State *L) {
+		Ray *inst = new Ray();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.Ray");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Ray_boxIntersect(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Ray *inst = (Ray*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 box = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Matrix4 transformMatrix = *(Matrix4*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number near = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number far = lua_tonumber(L, 5);
+		lua_pushnumber(L, inst->boxIntersect(box, transformMatrix, near, far));
+		return 1;
+	}
+	static int Polycode_Ray_planeIntersectPoint(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Ray *inst = (Ray*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 planeNormal = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number planeDistance = lua_tonumber(L, 3);
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->planeIntersectPoint(planeNormal, planeDistance);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Ray_tranformByMatrix(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Ray *inst = (Ray*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Matrix4 matrix = *(Matrix4*) *((PolyBase**)lua_touserdata(L, 2));
+		Ray *retInst = new Ray();
+		*retInst = inst->tranformByMatrix(matrix);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Ray");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Ray_closestPointOnRay(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Ray *inst = (Ray*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 point = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->closestPointOnRay(point);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Ray_closestPointsBetween(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Ray *inst = (Ray*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Ray ray2 = *(Ray*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Vector3* point1 = (Vector3*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		Vector3* point2 = (Vector3*) *((PolyBase**)lua_touserdata(L, 4));
+		lua_pushboolean(L, inst->closestPointsBetween(ray2, point1, point2));
+		return 1;
+	}
+	static int Polycode_Ray_polygonIntersect(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Ray *inst = (Ray*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 v1 = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Vector3 v2 = *(Vector3*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		Vector3 v3 = *(Vector3*) *((PolyBase**)lua_touserdata(L, 4));
+		lua_pushboolean(L, inst->polygonIntersect(v1, v2, v3));
+		return 1;
+	}
+	static int Polycode_Rectangle(lua_State *L) {
+		Rectangle *inst = new Rectangle();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.Rectangle");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Rectangle_setRect(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Rectangle *inst = (Rectangle*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number w = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number h = lua_tonumber(L, 5);
+		inst->setRect(x, y, w, h);
+		return 0;
+	}
+	static int Polycode_Rectangle_Clipped(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Rectangle *inst = (Rectangle*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Polycode::Rectangle rect = *(Polycode::Rectangle*) *((PolyBase**)lua_touserdata(L, 2));
+		Polycode::Rectangle *retInst = new Polycode::Rectangle();
+		*retInst = inst->Clipped(rect);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Polycode::Rectangle");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Rectangle_minX(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Rectangle *inst = (Rectangle*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->minX());
+		return 1;
+	}
+	static int Polycode_Rectangle_maxX(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Rectangle *inst = (Rectangle*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->maxX());
+		return 1;
+	}
+	static int Polycode_Rectangle_minY(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Rectangle *inst = (Rectangle*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->minY());
+		return 1;
+	}
+	static int Polycode_Rectangle_maxY(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Rectangle *inst = (Rectangle*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->maxY());
+		return 1;
+	}
+	static int Polycode_RenderDataArray(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TNUMBER);
+		int type = lua_tointeger(L, 1);
+		RenderDataArray *inst = new RenderDataArray(type);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.RenderDataArray");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_RenderDataArray_getArrayData(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		RenderDataArray *inst = (RenderDataArray*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getArrayData();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_RenderDataArray_getDataSize(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		RenderDataArray *inst = (RenderDataArray*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getDataSize());
+		return 1;
+	}
+	static int Polycode_VertexDataArray(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		char countPerVertex = *(char*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int type = lua_tointeger(L, 2);
+		VertexDataArray *inst = new VertexDataArray(countPerVertex, type);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.VertexDataArray");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_VertexDataArray_getCountPerVertex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		VertexDataArray *inst = (VertexDataArray*) *((PolyBase**)lua_touserdata(L, 1));
+		char *retInst = new char();
+		*retInst = inst->getCountPerVertex();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.char");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_VertexDataArray_getArrayData(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		VertexDataArray *inst = (VertexDataArray*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getArrayData();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_VertexDataArray_getDataSize(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		VertexDataArray *inst = (VertexDataArray*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getDataSize());
+		return 1;
+	}
+	static int Polycode_IndexDataArray(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TNUMBER);
+		int type = lua_tointeger(L, 1);
+		IndexDataArray *inst = new IndexDataArray(type);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.IndexDataArray");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_IndexDataArray_getArrayData(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		IndexDataArray *inst = (IndexDataArray*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getArrayData();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_IndexDataArray_getDataSize(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		IndexDataArray *inst = (IndexDataArray*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getDataSize());
+		return 1;
+	}
+	static int Polycode_RenderThread(lua_State *L) {
+		RenderThread *inst = new RenderThread();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.RenderThread");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_RenderThread_setGraphicsInterface(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		RenderThread *inst = (RenderThread*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Core* core = (Core*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		GraphicsInterface* graphicsInterface = (GraphicsInterface*) *((PolyBase**)lua_touserdata(L, 3));
+		inst->setGraphicsInterface(core, graphicsInterface);
+		return 0;
+	}
+	static int Polycode_RenderThread_runThread(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		RenderThread *inst = (RenderThread*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->runThread();
+		return 0;
+	}
+	static int Polycode_RenderThread_enqueueFrame(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		RenderThread *inst = (RenderThread*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		RenderFrame* frame = (RenderFrame*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->enqueueFrame(frame);
+		return 0;
+	}
+	static int Polycode_RenderThread_enqueueJob(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		RenderThread *inst = (RenderThread*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int jobType = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		void* data = (void*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		void* data2 = (void*) *((PolyBase**)lua_touserdata(L, 4));
+		inst->enqueueJob(jobType, data, data2);
+		return 0;
+	}
+	static int Polycode_RenderThread_processJob(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		RenderThread *inst = (RenderThread*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		RendererThreadJob job = *(RendererThreadJob*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->processJob(job);
+		return 0;
+	}
+	static int Polycode_RenderThread_getShaderBinding(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		RenderThread *inst = (RenderThread*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getShaderBinding();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_RenderThread_processDrawBuffer(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		RenderThread *inst = (RenderThread*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		GPUDrawBuffer* buffer = (GPUDrawBuffer*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->processDrawBuffer(buffer);
+		return 0;
+	}
+	static int Polycode_RenderThread_getFrameInfo(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		RenderThread *inst = (RenderThread*) *((PolyBase**)lua_touserdata(L, 1));
+		RenderThreadDebugInfo *retInst = new RenderThreadDebugInfo();
+		*retInst = inst->getFrameInfo();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.RenderThreadDebugInfo");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_RenderThread_clearFrameQueue(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		RenderThread *inst = (RenderThread*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->clearFrameQueue();
+		return 0;
+	}
+	static int Polycode_RenderThread_initGlobals(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		RenderThread *inst = (RenderThread*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->initGlobals();
+		return 0;
+	}
+	static int Polycode_RenderThread_lockRenderMutex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		RenderThread *inst = (RenderThread*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->lockRenderMutex();
+		return 0;
+	}
+	static int Polycode_RenderThread_unlockRenderMutex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		RenderThread *inst = (RenderThread*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->unlockRenderMutex();
+		return 0;
+	}
+	static int Polycode_Renderer_setGraphicsInterface(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Renderer *inst = (Renderer*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Core* core = (Core*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		GraphicsInterface* graphicsInterface = (GraphicsInterface*) *((PolyBase**)lua_touserdata(L, 3));
+		inst->setGraphicsInterface(core, graphicsInterface);
+		return 0;
+	}
+	static int Polycode_Renderer_getRenderThread(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Renderer *inst = (Renderer*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getRenderThread();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Renderer_createCubemap(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Renderer *inst = (Renderer*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Texture* t0 = (Texture*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Texture* t1 = (Texture*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		Texture* t2 = (Texture*) *((PolyBase**)lua_touserdata(L, 4));
+		luaL_checktype(L, 5, LUA_TUSERDATA);
+		Texture* t3 = (Texture*) *((PolyBase**)lua_touserdata(L, 5));
+		luaL_checktype(L, 6, LUA_TUSERDATA);
+		Texture* t4 = (Texture*) *((PolyBase**)lua_touserdata(L, 6));
+		luaL_checktype(L, 7, LUA_TUSERDATA);
+		Texture* t5 = (Texture*) *((PolyBase**)lua_touserdata(L, 7));
+		PolyBase *ptrRetVal = (PolyBase*)inst->createCubemap(t0, t1, t2, t3, t4, t5);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Renderer_createTexture(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Renderer *inst = (Renderer*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int width = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int height = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		char* textureData = (char*) *((PolyBase**)lua_touserdata(L, 4));
+		luaL_checktype(L, 5, LUA_TBOOLEAN);
+		bool clamp = lua_toboolean(L, 5) != 0;
+		luaL_checktype(L, 6, LUA_TBOOLEAN);
+		bool createMipmaps = lua_toboolean(L, 6) != 0;
+		luaL_checktype(L, 7, LUA_TNUMBER);
+		int type = lua_tointeger(L, 7);
+		luaL_checktype(L, 8, LUA_TNUMBER);
+		int filteringMode = lua_tointeger(L, 8);
+		luaL_checktype(L, 9, LUA_TNUMBER);
+		int anisotropy = lua_tointeger(L, 9);
+		luaL_checktype(L, 10, LUA_TBOOLEAN);
+		bool framebufferTexture = lua_toboolean(L, 10) != 0;
+		PolyBase *ptrRetVal = (PolyBase*)inst->createTexture(width, height, textureData, clamp, createMipmaps, type, filteringMode, anisotropy, framebufferTexture);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Renderer_createRenderBuffer(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Renderer *inst = (Renderer*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int width = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int height = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TBOOLEAN);
+		bool attachDepthBuffer = lua_toboolean(L, 4) != 0;
+		luaL_checktype(L, 5, LUA_TBOOLEAN);
+		bool floatingPoint = lua_toboolean(L, 5) != 0;
+		PolyBase *ptrRetVal = (PolyBase*)inst->createRenderBuffer(width, height, attachDepthBuffer, floatingPoint);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Renderer_destroyRenderBuffer(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Renderer *inst = (Renderer*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		RenderBuffer* buffer = (RenderBuffer*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->destroyRenderBuffer(buffer);
+		return 0;
+	}
+	static int Polycode_Renderer_destroyTexture(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Renderer *inst = (Renderer*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Texture* texture = (Texture*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->destroyTexture(texture);
+		return 0;
+	}
+	static int Polycode_Renderer_processDrawBuffer(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Renderer *inst = (Renderer*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		GPUDrawBuffer* buffer = (GPUDrawBuffer*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->processDrawBuffer(buffer);
+		return 0;
+	}
+	static int Polycode_Renderer_setBackingResolutionScale(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Renderer *inst = (Renderer*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number xScale = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number yScale = lua_tonumber(L, 3);
+		inst->setBackingResolutionScale(xScale, yScale);
+		return 0;
+	}
+	static int Polycode_Renderer_getBackingResolutionScaleX(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Renderer *inst = (Renderer*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getBackingResolutionScaleX());
+		return 1;
+	}
+	static int Polycode_Renderer_getBackingResolutionScaleY(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Renderer *inst = (Renderer*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getBackingResolutionScaleY());
+		return 1;
+	}
+	static int Polycode_Renderer_createProgram(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Renderer *inst = (Renderer*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 2));
+		PolyBase *ptrRetVal = (PolyBase*)inst->createProgram(fileName);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Renderer_createShader(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Renderer *inst = (Renderer*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ShaderProgram* vertexProgram = (ShaderProgram*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		ShaderProgram* fragmentProgram = (ShaderProgram*) *((PolyBase**)lua_touserdata(L, 3));
+		PolyBase *ptrRetVal = (PolyBase*)inst->createShader(vertexProgram, fragmentProgram);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Renderer_createVertexBuffers(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Renderer *inst = (Renderer*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Mesh* mesh = (Mesh*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->createVertexBuffers(mesh);
+		return 0;
+	}
+	static int Polycode_Renderer_enqueueFrameJob(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Renderer *inst = (Renderer*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int jobType = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		void* data = (void*) *((PolyBase**)lua_touserdata(L, 3));
+		inst->enqueueFrameJob(jobType, data);
+		return 0;
+	}
+	static int Polycode_Renderer_destroyProgram(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Renderer *inst = (Renderer*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ShaderProgram* program = (ShaderProgram*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->destroyProgram(program);
+		return 0;
+	}
+	static int Polycode_Renderer_destroyShader(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Renderer *inst = (Renderer*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Shader* shader = (Shader*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->destroyShader(shader);
+		return 0;
+	}
+	static int Polycode_Renderer_destroyBuffer(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Renderer *inst = (Renderer*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		RenderDataArray* array = (RenderDataArray*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->destroyBuffer(array);
+		return 0;
+	}
+	static int Polycode_Renderer_destroyShaderBinding(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Renderer *inst = (Renderer*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ShaderBinding* binding = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->destroyShaderBinding(binding);
+		return 0;
+	}
+	static int Polycode_Renderer_destroyShaderParam(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Renderer *inst = (Renderer*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		LocalShaderParam* param = (LocalShaderParam*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->destroyShaderParam(param);
+		return 0;
+	}
+	static int Polycode_Renderer_setTextureParam(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Renderer *inst = (Renderer*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		LocalShaderParam* param = (LocalShaderParam*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Texture* texture = (Texture*) *((PolyBase**)lua_touserdata(L, 3));
+		inst->setTextureParam(param, texture);
+		return 0;
+	}
+	static int Polycode_Renderer_setAnisotropyAmount(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Renderer *inst = (Renderer*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number amount = lua_tonumber(L, 2);
+		inst->setAnisotropyAmount(amount);
+		return 0;
+	}
+	static int Polycode_Renderer_getAnisotropyAmount(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Renderer *inst = (Renderer*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getAnisotropyAmount());
+		return 1;
+	}
+	static int Polycode_Renderer_createMesh(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Renderer *inst = (Renderer*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 2));
+		PolyBase *ptrRetVal = (PolyBase*)inst->createMesh(fileName);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Renderer_destroyMesh(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Renderer *inst = (Renderer*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Mesh* mesh = (Mesh*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->destroyMesh(mesh);
+		return 0;
+	}
+	static int Polycode_Renderer_unProject(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Renderer *inst = (Renderer*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 position = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Matrix4 modelMatrix = *(Matrix4*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		Matrix4 projectionMatrix = *(Matrix4*) *((PolyBase**)lua_touserdata(L, 4));
+		luaL_checktype(L, 5, LUA_TUSERDATA);
+		Polycode::Rectangle viewport = *(Polycode::Rectangle*) *((PolyBase**)lua_touserdata(L, 5));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->unProject(position, modelMatrix, projectionMatrix, viewport);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Renderer_project(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Renderer *inst = (Renderer*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 position = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Matrix4 modelMatrix = *(Matrix4*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		Matrix4 projectionMatrix = *(Matrix4*) *((PolyBase**)lua_touserdata(L, 4));
+		luaL_checktype(L, 5, LUA_TUSERDATA);
+		Polycode::Rectangle viewport = *(Polycode::Rectangle*) *((PolyBase**)lua_touserdata(L, 5));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->project(position, modelMatrix, projectionMatrix, viewport);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Renderer_beginFrame(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Renderer *inst = (Renderer*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->beginFrame();
+		return 0;
+	}
+	static int Polycode_Renderer_endFrame(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Renderer *inst = (Renderer*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->endFrame();
+		return 0;
+	}
+	static int Polycode_Resource(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TNUMBER);
+		int type = lua_tointeger(L, 1);
+		Resource *inst = new Resource(type);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.Resource");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Resource_reloadResource(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Resource *inst = (Resource*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->reloadResource();
+		return 0;
+	}
+	static int Polycode_Resource_getResourceName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Resource *inst = (Resource*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushstring(L, inst->getResourceName().c_str());
+		return 1;
+	}
+	static int Polycode_Resource_getResourceType(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Resource *inst = (Resource*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getResourceType());
+		return 1;
+	}
+	static int Polycode_Resource_setResourceName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Resource *inst = (Resource*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String newName = String(lua_tostring(L, 2));
+		inst->setResourceName(newName);
+		return 0;
+	}
+	static int Polycode_Resource_setResourcePath(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Resource *inst = (Resource*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String path = String(lua_tostring(L, 2));
+		inst->setResourcePath(path);
+		return 0;
+	}
+	static int Polycode_Resource_getResourcePath(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Resource *inst = (Resource*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushstring(L, inst->getResourcePath().c_str());
+		return 1;
+	}
+	static int Polycode_ScriptResourceLoader(lua_State *L) {
+		ScriptResourceLoader *inst = new ScriptResourceLoader();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.ScriptResourceLoader");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_ScriptResourceLoader_loadResource(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ScriptResourceLoader *inst = (ScriptResourceLoader*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String path = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		ResourcePool* targetPool = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 3));
+		PolyBase *ptrRetVal = (PolyBase*)inst->loadResource(path, targetPool);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_ResourcePool(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TSTRING);
+		String name = String(lua_tostring(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ResourcePool* fallbackPool = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 2));
+		ResourcePool *inst = new ResourcePool(name, fallbackPool);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.ResourcePool");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_ResourcePool_setFallbackPool(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ResourcePool *inst = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ResourcePool* pool = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setFallbackPool(pool);
+		return 0;
+	}
+	static int Polycode_ResourcePool_addResource(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ResourcePool *inst = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Resource* resource = (Resource*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->addResource(resource);
+		return 0;
+	}
+	static int Polycode_ResourcePool_removeResource(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ResourcePool *inst = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Resource* resource = (Resource*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->removeResource(resource);
+		return 0;
+	}
+	static int Polycode_ResourcePool_hasResource(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ResourcePool *inst = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Resource* resource = (Resource*) *((PolyBase**)lua_touserdata(L, 2));
+		lua_pushboolean(L, inst->hasResource(resource));
+		return 1;
+	}
+	static int Polycode_ResourcePool_loadResourcesFromFolder(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ResourcePool *inst = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String folder = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool recursive = lua_toboolean(L, 3) != 0;
+		inst->loadResourcesFromFolder(folder, recursive);
+		return 0;
+	}
+	static int Polycode_ResourcePool_loadResource(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ResourcePool *inst = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String path = String(lua_tostring(L, 2));
+		PolyBase *ptrRetVal = (PolyBase*)inst->loadResource(path);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_ResourcePool_loadResourceWithName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ResourcePool *inst = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String path = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String name = String(lua_tostring(L, 3));
+		PolyBase *ptrRetVal = (PolyBase*)inst->loadResourceWithName(path, name);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_ResourcePool_getResource(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ResourcePool *inst = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int resourceType = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String resourceName = String(lua_tostring(L, 3));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getResource(resourceType, resourceName);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_ResourcePool_getName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ResourcePool *inst = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushstring(L, inst->getName().c_str());
+		return 1;
+	}
+	static int Polycode_ResourcePool_setName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ResourcePool *inst = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String name = String(lua_tostring(L, 2));
+		inst->setName(name);
+		return 0;
+	}
+	static int Polycode_ResourcePool_getResourceByPath(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ResourcePool *inst = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String resourcePath = String(lua_tostring(L, 2));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getResourceByPath(resourcePath);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_ResourcePool_Update(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ResourcePool *inst = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int elapsed = lua_tointeger(L, 2);
+		inst->Update(elapsed);
+		return 0;
+	}
+	static int Polycode_ResourcePool_getResources(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ResourcePool *inst = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int resourceType = lua_tointeger(L, 2);
+	}
+	static int Polycode_ResourcePool_checkForChangedFiles(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ResourcePool *inst = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->checkForChangedFiles();
+		return 0;
+	}
+	static int Polycode_ResourceManager(lua_State *L) {
+		ResourceManager *inst = new ResourceManager();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.ResourceManager");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_ResourceManager_getGlobalPool(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ResourceManager *inst = (ResourceManager*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getGlobalPool();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_ResourceManager_getResourcePoolByName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ResourceManager *inst = (ResourceManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String name = String(lua_tostring(L, 2));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getResourcePoolByName(name);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_ResourceManager_addResourceLoader(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ResourceManager *inst = (ResourceManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ResourceLoader* loader = (ResourceLoader*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->addResourceLoader(loader);
+		return 0;
+	}
+	static int Polycode_ResourceManager_getResourceLoaderForExtension(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ResourceManager *inst = (ResourceManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String extension = String(lua_tostring(L, 2));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getResourceLoaderForExtension(extension);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_ResourceManager_removeResourceLoader(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ResourceManager *inst = (ResourceManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ResourceLoader* loader = (ResourceLoader*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->removeResourceLoader(loader);
+		return 0;
+	}
+	static int Polycode_ResourceManager_getNumResourceLoaders(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ResourceManager *inst = (ResourceManager*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getNumResourceLoaders());
+		return 1;
+	}
+	static int Polycode_ResourceManager_getResourceLoaderAtIndex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ResourceManager *inst = (ResourceManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->getResourceLoaderAtIndex(index);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_ResourceManager_addResourcePool(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ResourceManager *inst = (ResourceManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ResourcePool* pool = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->addResourcePool(pool);
+		return 0;
+	}
+	static int Polycode_ResourceManager_removeResourcePool(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ResourceManager *inst = (ResourceManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ResourcePool* pool = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->removeResourcePool(pool);
+		return 0;
+	}
+	static int Polycode_ResourceManager_getResources(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ResourceManager *inst = (ResourceManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int resourceType = lua_tointeger(L, 2);
+	}
+	static int Polycode_ResourceManager_removeResource(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ResourceManager *inst = (ResourceManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Resource* resource = (Resource*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->removeResource(resource);
+		return 0;
+	}
+	static int Polycode_ResourceManager_subscribeToResourcePool(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ResourceManager *inst = (ResourceManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ResourcePool* pool = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->subscribeToResourcePool(pool);
+		return 0;
+	}
+	static int Polycode_ResourceManager_unsubscibeFromResourcePool(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ResourceManager *inst = (ResourceManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ResourcePool* pool = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->unsubscibeFromResourcePool(pool);
+		return 0;
+	}
+	static int Polycode_ResourceManager_Update(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ResourceManager *inst = (ResourceManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int elapsed = lua_tointeger(L, 2);
+		inst->Update(elapsed);
+		return 0;
+	}
+	static int Polycode_FontResourceLoader(lua_State *L) {
+		FontResourceLoader *inst = new FontResourceLoader();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.FontResourceLoader");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_FontResourceLoader_loadResource(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		FontResourceLoader *inst = (FontResourceLoader*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String path = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		ResourcePool* targetPool = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 3));
+		PolyBase *ptrRetVal = (PolyBase*)inst->loadResource(path, targetPool);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_ProgramResourceLoader(lua_State *L) {
+		ProgramResourceLoader *inst = new ProgramResourceLoader();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.ProgramResourceLoader");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_ProgramResourceLoader_loadResource(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ProgramResourceLoader *inst = (ProgramResourceLoader*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String path = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		ResourcePool* targetPool = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 3));
+		PolyBase *ptrRetVal = (PolyBase*)inst->loadResource(path, targetPool);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_MeshResourceLoader(lua_State *L) {
+		MeshResourceLoader *inst = new MeshResourceLoader();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.MeshResourceLoader");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_MeshResourceLoader_loadResource(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		MeshResourceLoader *inst = (MeshResourceLoader*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String path = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		ResourcePool* targetPool = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 3));
+		PolyBase *ptrRetVal = (PolyBase*)inst->loadResource(path, targetPool);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_MaterialResourceLoader(lua_State *L) {
+		MaterialResourceLoader *inst = new MaterialResourceLoader();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.MaterialResourceLoader");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_MaterialResourceLoader_loadResource(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		MaterialResourceLoader *inst = (MaterialResourceLoader*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String path = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		ResourcePool* targetPool = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 3));
+		PolyBase *ptrRetVal = (PolyBase*)inst->loadResource(path, targetPool);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_TextureResourceLoader(lua_State *L) {
+		TextureResourceLoader *inst = new TextureResourceLoader();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.TextureResourceLoader");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_TextureResourceLoader_loadResource(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		TextureResourceLoader *inst = (TextureResourceLoader*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String path = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		ResourcePool* targetPool = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 3));
+		PolyBase *ptrRetVal = (PolyBase*)inst->loadResource(path, targetPool);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Scene(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TNUMBER);
+		int sceneType = lua_tointeger(L, 1);
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool virtualScene = lua_toboolean(L, 2) != 0;
+		Scene *inst = new Scene(sceneType, virtualScene);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.Scene");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Scene_addEntity(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Scene *inst = (Scene*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Entity* entity = (Entity*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->addEntity(entity);
+		return 0;
+	}
+	static int Polycode_Scene_addChild(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Scene *inst = (Scene*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Entity* entity = (Entity*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->addChild(entity);
+		return 0;
+	}
+	static int Polycode_Scene_removeEntity(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Scene *inst = (Scene*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Entity* entity = (Entity*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->removeEntity(entity);
+		return 0;
+	}
+	static int Polycode_Scene_getDefaultCamera(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Scene *inst = (Scene*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getDefaultCamera();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Scene_getActiveCamera(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Scene *inst = (Scene*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getActiveCamera();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Scene_setActiveCamera(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Scene *inst = (Scene*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Camera* camera = (Camera*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setActiveCamera(camera);
+		return 0;
+	}
+	static int Polycode_Scene_enableFog(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Scene *inst = (Scene*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool enable = lua_toboolean(L, 2) != 0;
+		inst->enableFog(enable);
+		return 0;
+	}
+	static int Polycode_Scene_setFogProperties(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Scene *inst = (Scene*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int fogMode = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Color color = *(Color*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number density = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number startDepth = lua_tonumber(L, 5);
+		luaL_checktype(L, 6, LUA_TNUMBER);
+		Number endDepth = lua_tonumber(L, 6);
+		inst->setFogProperties(fogMode, color, density, startDepth, endDepth);
+		return 0;
+	}
+	static int Polycode_Scene_setSceneType(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Scene *inst = (Scene*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int newType = lua_tointeger(L, 2);
+		inst->setSceneType(newType);
+		return 0;
+	}
+	static int Polycode_Scene_fixedUpdate(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Scene *inst = (Scene*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->fixedUpdate();
+		return 0;
+	}
+	static int Polycode_Scene_Update(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Scene *inst = (Scene*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->Update();
+		return 0;
+	}
+	static int Polycode_Scene_setVirtual(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Scene *inst = (Scene*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool val = lua_toboolean(L, 2) != 0;
+		inst->setVirtual(val);
+		return 0;
+	}
+	static int Polycode_Scene_isVirtual(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Scene *inst = (Scene*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->isVirtual());
+		return 1;
+	}
+	static int Polycode_Scene_isEnabled(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Scene *inst = (Scene*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->isEnabled());
+		return 1;
+	}
+	static int Polycode_Scene_setEnabled(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Scene *inst = (Scene*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool enabled = lua_toboolean(L, 2) != 0;
+		inst->setEnabled(enabled);
+		return 0;
+	}
+	static int Polycode_Scene_Render(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Scene *inst = (Scene*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Camera* targetCamera = (Camera*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		RenderBuffer* targetFramebuffer = (RenderBuffer*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		Material* overrideMaterial = (Material*) *((PolyBase**)lua_touserdata(L, 4));
+		luaL_checktype(L, 5, LUA_TBOOLEAN);
+		bool sendLights = lua_toboolean(L, 5) != 0;
+		inst->Render(targetCamera, targetFramebuffer, overrideMaterial, sendLights);
+		return 0;
+	}
+	static int Polycode_Scene_setOverrideMaterial(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Scene *inst = (Scene*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Material* material = (Material*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setOverrideMaterial(material);
+		return 0;
+	}
+	static int Polycode_Scene_projectRayFromCameraAndViewportCoordinate(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Scene *inst = (Scene*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Camera* camera = (Camera*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Vector2 coordinate = *(Vector2*) *((PolyBase**)lua_touserdata(L, 3));
+		Ray *retInst = new Ray();
+		*retInst = inst->projectRayFromCameraAndViewportCoordinate(camera, coordinate);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Ray");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Scene_addLight(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Scene *inst = (Scene*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		SceneLight* light = (SceneLight*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->addLight(light);
+		return 0;
+	}
+	static int Polycode_Scene_removeLight(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Scene *inst = (Scene*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		SceneLight* light = (SceneLight*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->removeLight(light);
+		return 0;
+	}
+	static int Polycode_Scene_getNumLights(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Scene *inst = (Scene*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getNumLights());
+		return 1;
+	}
+	static int Polycode_Scene_getLight(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Scene *inst = (Scene*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->getLight(index);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Scene_doVisibilityChecking(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Scene *inst = (Scene*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool val = lua_toboolean(L, 2) != 0;
+		inst->doVisibilityChecking(val);
+		return 0;
+	}
+	static int Polycode_Scene_doesVisibilityChecking(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Scene *inst = (Scene*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->doesVisibilityChecking());
+		return 1;
+	}
+	static int Polycode_SceneEntityInstanceResourceEntry(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneEntityInstance* instance = (SceneEntityInstance*) *((PolyBase**)lua_touserdata(L, 1));
+		SceneEntityInstanceResourceEntry *inst = new SceneEntityInstanceResourceEntry(instance);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.SceneEntityInstanceResourceEntry");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_SceneEntityInstanceResourceEntry_getInstance(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneEntityInstanceResourceEntry *inst = (SceneEntityInstanceResourceEntry*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getInstance();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneEntityInstanceResourceEntry_reloadResource(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneEntityInstanceResourceEntry *inst = (SceneEntityInstanceResourceEntry*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->reloadResource();
+		return 0;
+	}
+	static int Polycode_SceneEntityInstance(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Scene* parentScene = (Scene*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 2));
+		SceneEntityInstance *inst = new SceneEntityInstance(parentScene, fileName);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.SceneEntityInstance");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_SceneEntityInstance_BlankSceneEntityInstance(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneEntityInstance *inst = (SceneEntityInstance*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Scene* parentScene = (Scene*) *((PolyBase**)lua_touserdata(L, 2));
+		PolyBase *ptrRetVal = (PolyBase*)inst->BlankSceneEntityInstance(parentScene);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneEntityInstance_Clone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneEntityInstance *inst = (SceneEntityInstance*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool deepClone = lua_toboolean(L, 2) != 0;
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool ignoreEditorOnly = lua_toboolean(L, 3) != 0;
+		PolyBase *ptrRetVal = (PolyBase*)inst->Clone(deepClone, ignoreEditorOnly);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneEntityInstance_applyClone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneEntityInstance *inst = (SceneEntityInstance*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Entity* clone = (Entity*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool deepClone = lua_toboolean(L, 3) != 0;
+		luaL_checktype(L, 4, LUA_TBOOLEAN);
+		bool ignoreEditorOnly = lua_toboolean(L, 4) != 0;
+		inst->applyClone(clone, deepClone, ignoreEditorOnly);
+		return 0;
+	}
+	static int Polycode_SceneEntityInstance_reloadEntityInstance(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneEntityInstance *inst = (SceneEntityInstance*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->reloadEntityInstance();
+		return 0;
+	}
+	static int Polycode_SceneEntityInstance_clearInstance(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneEntityInstance *inst = (SceneEntityInstance*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->clearInstance();
+		return 0;
+	}
+	static int Polycode_SceneEntityInstance_parseObjectIntoCurve(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneEntityInstance *inst = (SceneEntityInstance*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ObjectEntry* entry = (ObjectEntry*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		BezierCurve* curve = (BezierCurve*) *((PolyBase**)lua_touserdata(L, 3));
+		inst->parseObjectIntoCurve(entry, curve);
+		return 0;
+	}
+	static int Polycode_SceneEntityInstance_loadObjectEntryIntoEntity(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneEntityInstance *inst = (SceneEntityInstance*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ObjectEntry* entry = (ObjectEntry*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Entity* targetEntity = (Entity*) *((PolyBase**)lua_touserdata(L, 3));
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int entityFileVersion = lua_tointeger(L, 4);
+		PolyBase *ptrRetVal = (PolyBase*)inst->loadObjectEntryIntoEntity(entry, targetEntity, entityFileVersion);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneEntityInstance_loadFromFile(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneEntityInstance *inst = (SceneEntityInstance*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 2));
+		lua_pushboolean(L, inst->loadFromFile(fileName));
+		return 1;
+	}
+	static int Polycode_SceneEntityInstance_applySceneMesh(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneEntityInstance *inst = (SceneEntityInstance*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ObjectEntry* entry = (ObjectEntry*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		SceneMesh* sceneMesh = (SceneMesh*) *((PolyBase**)lua_touserdata(L, 3));
+		inst->applySceneMesh(entry, sceneMesh);
+		return 0;
+	}
+	static int Polycode_SceneEntityInstance_linkResourcePool(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneEntityInstance *inst = (SceneEntityInstance*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ResourcePool* pool = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->linkResourcePool(pool);
+		return 0;
+	}
+	static int Polycode_SceneEntityInstance_getNumLinkedResourePools(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneEntityInstance *inst = (SceneEntityInstance*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getNumLinkedResourePools());
+		return 1;
+	}
+	static int Polycode_SceneEntityInstance_getLinkedResourcePoolAtIndex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneEntityInstance *inst = (SceneEntityInstance*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->getLinkedResourcePoolAtIndex(index);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneEntityInstance_unlinkResourcePool(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneEntityInstance *inst = (SceneEntityInstance*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ResourcePool* pool = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->unlinkResourcePool(pool);
+		return 0;
+	}
+	static int Polycode_SceneEntityInstance_getResourceEntry(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneEntityInstance *inst = (SceneEntityInstance*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getResourceEntry();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneEntityInstance_getTopLevelResourcePool(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneEntityInstance *inst = (SceneEntityInstance*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getTopLevelResourcePool();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneEntityInstance_hasLayerID(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneEntityInstance *inst = (SceneEntityInstance*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		char layerID = *(char*) *((PolyBase**)lua_touserdata(L, 2));
+		lua_pushboolean(L, inst->hasLayerID(layerID));
+		return 1;
+	}
+	static int Polycode_SceneEntityInstance_getNumLayers(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneEntityInstance *inst = (SceneEntityInstance*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getNumLayers());
+		return 1;
+	}
+	static int Polycode_SceneEntityInstance_getLayerAtIndex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneEntityInstance *inst = (SceneEntityInstance*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->getLayerAtIndex(index);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneEntityInstance_removeLayer(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneEntityInstance *inst = (SceneEntityInstance*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		SceneEntityInstanceLayer* layer = (SceneEntityInstanceLayer*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->removeLayer(layer);
+		return 0;
+	}
+	static int Polycode_SceneEntityInstance_createNewLayer(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneEntityInstance *inst = (SceneEntityInstance*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String name = String(lua_tostring(L, 2));
+		PolyBase *ptrRetVal = (PolyBase*)inst->createNewLayer(name);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneEntityInstance_getFileName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneEntityInstance *inst = (SceneEntityInstance*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushstring(L, inst->getFileName().c_str());
+		return 1;
+	}
+	static int Polycode_SceneEntityInstanceLayer(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneEntityInstance* instance = (SceneEntityInstance*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String name = String(lua_tostring(L, 2));
+		SceneEntityInstanceLayer *inst = new SceneEntityInstanceLayer(instance, name);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.SceneEntityInstanceLayer");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_SceneEntityInstanceLayer_setLayerVisibility(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneEntityInstanceLayer *inst = (SceneEntityInstanceLayer*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool val = lua_toboolean(L, 2) != 0;
+		inst->setLayerVisibility(val);
+		return 0;
+	}
+	static int Polycode_SceneImage(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 1));
+		SceneImage *inst = new SceneImage(fileName);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.SceneImage");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_SceneImage_SceneImageWithImage(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneImage *inst = (SceneImage*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Image* image = (Image*) *((PolyBase**)lua_touserdata(L, 2));
+		PolyBase *ptrRetVal = (PolyBase*)inst->SceneImageWithImage(image);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneImage_SceneImageWithTexture(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneImage *inst = (SceneImage*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Texture* texture = (Texture*) *((PolyBase**)lua_touserdata(L, 2));
+		PolyBase *ptrRetVal = (PolyBase*)inst->SceneImageWithTexture(texture);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneImage_Clone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneImage *inst = (SceneImage*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool deepClone = lua_toboolean(L, 2) != 0;
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool ignoreEditorOnly = lua_toboolean(L, 3) != 0;
+		PolyBase *ptrRetVal = (PolyBase*)inst->Clone(deepClone, ignoreEditorOnly);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneImage_applyClone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneImage *inst = (SceneImage*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Entity* clone = (Entity*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool deepClone = lua_toboolean(L, 3) != 0;
+		luaL_checktype(L, 4, LUA_TBOOLEAN);
+		bool ignoreEditorOnly = lua_toboolean(L, 4) != 0;
+		inst->applyClone(clone, deepClone, ignoreEditorOnly);
+		return 0;
+	}
+	static int Polycode_SceneImage_setImageCoordinates(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneImage *inst = (SceneImage*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number width = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number height = lua_tonumber(L, 5);
+		luaL_checktype(L, 6, LUA_TNUMBER);
+		Number realWidth = lua_tonumber(L, 6);
+		luaL_checktype(L, 7, LUA_TNUMBER);
+		Number realHeight = lua_tonumber(L, 7);
+		inst->setImageCoordinates(x, y, width, height, realWidth, realHeight);
+		return 0;
+	}
+	static int Polycode_SceneImage_getImageWidth(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneImage *inst = (SceneImage*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getImageWidth());
+		return 1;
+	}
+	static int Polycode_SceneImage_getImageHeight(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneImage *inst = (SceneImage*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getImageHeight());
+		return 1;
+	}
+	static int Polycode_SceneLabel(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TSTRING);
+		String text = String(lua_tostring(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int size = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String fontName = String(lua_tostring(L, 3));
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int amode = lua_tointeger(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number actualHeight = lua_tonumber(L, 5);
+		luaL_checktype(L, 6, LUA_TBOOLEAN);
+		bool premultiplyAlpha = lua_toboolean(L, 6) != 0;
+		luaL_checktype(L, 7, LUA_TUSERDATA);
+		Color backgroundColor = *(Color*) *((PolyBase**)lua_touserdata(L, 7));
+		luaL_checktype(L, 8, LUA_TUSERDATA);
+		Color foregroundColor = *(Color*) *((PolyBase**)lua_touserdata(L, 8));
+		SceneLabel *inst = new SceneLabel(text, size, fontName, amode, actualHeight, premultiplyAlpha, backgroundColor, foregroundColor);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.SceneLabel");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_SceneLabel_getText(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLabel *inst = (SceneLabel*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushstring(L, inst->getText().c_str());
+		return 1;
+	}
+	static int Polycode_SceneLabel_setLabelActualHeight(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLabel *inst = (SceneLabel*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number actualHeight = lua_tonumber(L, 2);
+		inst->setLabelActualHeight(actualHeight);
+		return 0;
+	}
+	static int Polycode_SceneLabel_getLabelActualHeight(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLabel *inst = (SceneLabel*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getLabelActualHeight());
+		return 1;
+	}
+	static int Polycode_SceneLabel_Render(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLabel *inst = (SceneLabel*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		GPUDrawBuffer* buffer = (GPUDrawBuffer*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->Render(buffer);
+		return 0;
+	}
+	static int Polycode_SceneLabel_getTextWidthForString(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLabel *inst = (SceneLabel*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String text = String(lua_tostring(L, 2));
+		lua_pushinteger(L, inst->getTextWidthForString(text));
+		return 1;
+	}
+	static int Polycode_SceneLabel_setText(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLabel *inst = (SceneLabel*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String newText = String(lua_tostring(L, 2));
+		inst->setText(newText);
+		return 0;
+	}
+	static int Polycode_SceneLabel_Clone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLabel *inst = (SceneLabel*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool deepClone = lua_toboolean(L, 2) != 0;
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool ignoreEditorOnly = lua_toboolean(L, 3) != 0;
+		PolyBase *ptrRetVal = (PolyBase*)inst->Clone(deepClone, ignoreEditorOnly);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneLabel_applyClone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLabel *inst = (SceneLabel*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Entity* clone = (Entity*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool deepClone = lua_toboolean(L, 3) != 0;
+		luaL_checktype(L, 4, LUA_TBOOLEAN);
+		bool ignoreEditorOnly = lua_toboolean(L, 4) != 0;
+		inst->applyClone(clone, deepClone, ignoreEditorOnly);
+		return 0;
+	}
+	static int Polycode_SceneLabel_updateFromLabel(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLabel *inst = (SceneLabel*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->updateFromLabel();
+		return 0;
+	}
+	static int Polycode_SceneLabel_getLabel(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLabel *inst = (SceneLabel*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getLabel();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneLight(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TNUMBER);
+		int type = lua_tointeger(L, 1);
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Scene* parentScene = (Scene*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number intensity = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number constantAttenuation = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number linearAttenuation = lua_tonumber(L, 5);
+		luaL_checktype(L, 6, LUA_TNUMBER);
+		Number quadraticAttenuation = lua_tonumber(L, 6);
+		SceneLight *inst = new SceneLight(type, parentScene, intensity, constantAttenuation, linearAttenuation, quadraticAttenuation);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.SceneLight");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_SceneLight_getIntensity(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLight *inst = (SceneLight*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getIntensity());
+		return 1;
+	}
+	static int Polycode_SceneLight_setIntensity(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLight *inst = (SceneLight*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number newIntensity = lua_tonumber(L, 2);
+		inst->setIntensity(newIntensity);
+		return 0;
+	}
+	static int Polycode_SceneLight_setAttenuation(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLight *inst = (SceneLight*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number constantAttenuation = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number linearAttenuation = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number quadraticAttenuation = lua_tonumber(L, 4);
+		inst->setAttenuation(constantAttenuation, linearAttenuation, quadraticAttenuation);
+		return 0;
+	}
+	static int Polycode_SceneLight_getConstantAttenuation(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLight *inst = (SceneLight*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getConstantAttenuation());
+		return 1;
+	}
+	static int Polycode_SceneLight_getLinearAttenuation(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLight *inst = (SceneLight*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getLinearAttenuation());
+		return 1;
+	}
+	static int Polycode_SceneLight_getQuadraticAttenuation(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLight *inst = (SceneLight*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getQuadraticAttenuation());
+		return 1;
+	}
+	static int Polycode_SceneLight_getType(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLight *inst = (SceneLight*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getType());
+		return 1;
+	}
+	static int Polycode_SceneLight_renderDepthMap(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLight *inst = (SceneLight*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Scene* scene = (Scene*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->renderDepthMap(scene);
+		return 0;
+	}
+	static int Polycode_SceneLight_getZBufferTexture(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLight *inst = (SceneLight*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getZBufferTexture();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneLight_setSpecularLightColor(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLight *inst = (SceneLight*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number r = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number g = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number b = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number a = lua_tonumber(L, 5);
+		inst->setSpecularLightColor(r, g, b, a);
+		return 0;
+	}
+	static int Polycode_SceneLight_setDiffuseLightColor(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLight *inst = (SceneLight*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number r = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number g = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number b = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number a = lua_tonumber(L, 5);
+		inst->setDiffuseLightColor(r, g, b, a);
+		return 0;
+	}
+	static int Polycode_SceneLight_setLightColor(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLight *inst = (SceneLight*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number r = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number g = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number b = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number a = lua_tonumber(L, 5);
+		inst->setLightColor(r, g, b, a);
+		return 0;
+	}
+	static int Polycode_SceneLight_setSpotlightProperties(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLight *inst = (SceneLight*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number spotlightCutoff = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number spotlightExponent = lua_tonumber(L, 3);
+		inst->setSpotlightProperties(spotlightCutoff, spotlightExponent);
+		return 0;
+	}
+	static int Polycode_SceneLight_getSpotlightCutoff(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLight *inst = (SceneLight*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getSpotlightCutoff());
+		return 1;
+	}
+	static int Polycode_SceneLight_getSpotlightExponent(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLight *inst = (SceneLight*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getSpotlightExponent());
+		return 1;
+	}
+	static int Polycode_SceneLight_enableShadows(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLight *inst = (SceneLight*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool val = lua_toboolean(L, 2) != 0;
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int resolution = lua_tointeger(L, 3);
+		inst->enableShadows(val, resolution);
+		return 0;
+	}
+	static int Polycode_SceneLight_setShadowMapFOV(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLight *inst = (SceneLight*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number fov = lua_tonumber(L, 2);
+		inst->setShadowMapFOV(fov);
+		return 0;
+	}
+	static int Polycode_SceneLight_getShadowMapFOV(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLight *inst = (SceneLight*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getShadowMapFOV());
+		return 1;
+	}
+	static int Polycode_SceneLight_getShadowMapResolution(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLight *inst = (SceneLight*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getShadowMapResolution());
+		return 1;
+	}
+	static int Polycode_SceneLight_areShadowsEnabled(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLight *inst = (SceneLight*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->areShadowsEnabled());
+		return 1;
+	}
+	static int Polycode_SceneLight_getLightType(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLight *inst = (SceneLight*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getLightType());
+		return 1;
+	}
+	static int Polycode_SceneLight_setLightImportance(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLight *inst = (SceneLight*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int newImportance = lua_tointeger(L, 2);
+		inst->setLightImportance(newImportance);
+		return 0;
+	}
+	static int Polycode_SceneLight_getLightImportance(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLight *inst = (SceneLight*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getLightImportance());
+		return 1;
+	}
+	static int Polycode_SceneLight_setLightType(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLight *inst = (SceneLight*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int lightType = lua_tointeger(L, 2);
+		inst->setLightType(lightType);
+		return 0;
+	}
+	static int Polycode_SceneLight_Clone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLight *inst = (SceneLight*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool deepClone = lua_toboolean(L, 2) != 0;
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool ignoreEditorOnly = lua_toboolean(L, 3) != 0;
+		PolyBase *ptrRetVal = (PolyBase*)inst->Clone(deepClone, ignoreEditorOnly);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneLight_applyClone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLight *inst = (SceneLight*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Entity* clone = (Entity*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool deepClone = lua_toboolean(L, 3) != 0;
+		luaL_checktype(L, 4, LUA_TBOOLEAN);
+		bool ignoreEditorOnly = lua_toboolean(L, 4) != 0;
+		inst->applyClone(clone, deepClone, ignoreEditorOnly);
+		return 0;
+	}
+	static int Polycode_SceneLight_getParentScene(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLight *inst = (SceneLight*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getParentScene();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneLight_setParentScene(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLight *inst = (SceneLight*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Scene* scene = (Scene*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setParentScene(scene);
+		return 0;
+	}
+	static int Polycode_SceneLight_getSpotlightCamera(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLight *inst = (SceneLight*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getSpotlightCamera();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneLight_getLightInfo(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLight *inst = (SceneLight*) *((PolyBase**)lua_touserdata(L, 1));
+		LightInfo *retInst = new LightInfo();
+		*retInst = inst->getLightInfo();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.LightInfo");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_SceneCurve(lua_State *L) {
+		SceneCurve *inst = new SceneCurve();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.SceneCurve");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_SceneCurve_SceneCurveWithCurve(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneCurve *inst = (SceneCurve*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		BezierCurve* curve = (BezierCurve*) *((PolyBase**)lua_touserdata(L, 2));
+		PolyBase *ptrRetVal = (PolyBase*)inst->SceneCurveWithCurve(curve);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneCurve_getWorldPointAt(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneCurve *inst = (SceneCurve*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number t = lua_tonumber(L, 2);
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->getWorldPointAt(t);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_SceneCurve_Update(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneCurve *inst = (SceneCurve*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->Update();
+		return 0;
+	}
+	static int Polycode_SceneCurve_Clone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneCurve *inst = (SceneCurve*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool deepClone = lua_toboolean(L, 2) != 0;
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool ignoreEditorOnly = lua_toboolean(L, 3) != 0;
+		PolyBase *ptrRetVal = (PolyBase*)inst->Clone(deepClone, ignoreEditorOnly);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneCurve_applyClone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneCurve *inst = (SceneCurve*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Entity* clone = (Entity*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool deepClone = lua_toboolean(L, 3) != 0;
+		luaL_checktype(L, 4, LUA_TBOOLEAN);
+		bool ignoreEditorOnly = lua_toboolean(L, 4) != 0;
+		inst->applyClone(clone, deepClone, ignoreEditorOnly);
+		return 0;
+	}
+	static int Polycode_SceneCurve_getCurve(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneCurve *inst = (SceneCurve*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getCurve();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneLine(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Entity* ent1 = (Entity*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Entity* ent2 = (Entity*) *((PolyBase**)lua_touserdata(L, 2));
+		SceneLine *inst = new SceneLine(ent1, ent2);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.SceneLine");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_SceneLine_SceneLineWithPositions(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLine *inst = (SceneLine*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 start = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Vector3 end = *(Vector3*) *((PolyBase**)lua_touserdata(L, 3));
+		PolyBase *ptrRetVal = (PolyBase*)inst->SceneLineWithPositions(start, end);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneLine_setStart(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLine *inst = (SceneLine*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 start = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setStart(start);
+		return 0;
+	}
+	static int Polycode_SceneLine_setEnd(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLine *inst = (SceneLine*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 end = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setEnd(end);
+		return 0;
+	}
+	static int Polycode_SceneLine_Update(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneLine *inst = (SceneLine*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->Update();
+		return 0;
+	}
+	static int Polycode_SceneManager(lua_State *L) {
+		SceneManager *inst = new SceneManager();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.SceneManager");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_SceneManager_addScene(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneManager *inst = (SceneManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Scene* newScene = (Scene*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->addScene(newScene);
+		return 0;
+	}
+	static int Polycode_SceneManager_removeScene(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneManager *inst = (SceneManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Scene* scene = (Scene*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->removeScene(scene);
+		return 0;
+	}
+	static int Polycode_SceneManager_Update(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneManager *inst = (SceneManager*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->Update();
+		return 0;
+	}
+	static int Polycode_SceneManager_fixedUpdate(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneManager *inst = (SceneManager*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->fixedUpdate();
+		return 0;
+	}
+	static int Polycode_SceneManager_Render(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneManager *inst = (SceneManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Polycode::Rectangle viewport = *(Polycode::Rectangle*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->Render(viewport);
+		return 0;
+	}
+	static int Polycode_SceneManager_renderVirtual(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneManager *inst = (SceneManager*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->renderVirtual();
+		return 0;
+	}
+	static int Polycode_SceneManager_registerRenderTexture(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneManager *inst = (SceneManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		SceneRenderTexture* renderTexture = (SceneRenderTexture*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->registerRenderTexture(renderTexture);
+		return 0;
+	}
+	static int Polycode_SceneManager_unregisterRenderTexture(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneManager *inst = (SceneManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		SceneRenderTexture* renderTexture = (SceneRenderTexture*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->unregisterRenderTexture(renderTexture);
+		return 0;
+	}
+	static int Polycode_SceneManager_setRenderer(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneManager *inst = (SceneManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Renderer* renderer = (Renderer*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setRenderer(renderer);
+		return 0;
+	}
+	static int Polycode_SceneMesh(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 1));
+		SceneMesh *inst = new SceneMesh(fileName);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.SceneMesh");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_SceneMesh_SceneMeshFromMesh(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneMesh *inst = (SceneMesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Mesh* mesh = (Mesh*) *((PolyBase**)lua_touserdata(L, 2));
+		PolyBase *ptrRetVal = (PolyBase*)inst->SceneMeshFromMesh(mesh);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneMesh_SceneMeshWithType(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneMesh *inst = (SceneMesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int meshType = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->SceneMeshWithType(meshType);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneMesh_Render(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneMesh *inst = (SceneMesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		GPUDrawBuffer* buffer = (GPUDrawBuffer*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->Render(buffer);
+		return 0;
+	}
+	static int Polycode_SceneMesh_getShaderPass(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneMesh *inst = (SceneMesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		ShaderPass *retInst = new ShaderPass();
+		*retInst = inst->getShaderPass(index);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.ShaderPass");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_SceneMesh_getNumShaderPasses(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneMesh *inst = (SceneMesh*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getNumShaderPasses());
+		return 1;
+	}
+	static int Polycode_SceneMesh_addShaderPass(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneMesh *inst = (SceneMesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ShaderPass pass = *(ShaderPass*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->addShaderPass(pass);
+		return 0;
+	}
+	static int Polycode_SceneMesh_removeShaderPass(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneMesh *inst = (SceneMesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int shaderIndex = lua_tointeger(L, 2);
+		inst->removeShaderPass(shaderIndex);
+		return 0;
+	}
+	static int Polycode_SceneMesh_getMesh(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneMesh *inst = (SceneMesh*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getMesh();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneMesh_getMaterial(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneMesh *inst = (SceneMesh*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getMaterial();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneMesh_loadSkeleton(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneMesh *inst = (SceneMesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 2));
+		PolyBase *ptrRetVal = (PolyBase*)inst->loadSkeleton(fileName);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneMesh_clearMaterial(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneMesh *inst = (SceneMesh*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->clearMaterial();
+		return 0;
+	}
+	static int Polycode_SceneMesh_setMaterial(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneMesh *inst = (SceneMesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Material* material = (Material*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setMaterial(material);
+		return 0;
+	}
+	static int Polycode_SceneMesh_rebuildAttributes(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneMesh *inst = (SceneMesh*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->rebuildAttributes();
+		return 0;
+	}
+	static int Polycode_SceneMesh_setMaterialByName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneMesh *inst = (SceneMesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String materialName = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		ResourcePool* resourcePool = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 3));
+		inst->setMaterialByName(materialName, resourcePool);
+		return 0;
+	}
+	static int Polycode_SceneMesh_setMesh(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneMesh *inst = (SceneMesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Mesh* mesh = (Mesh*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setMesh(mesh);
+		return 0;
+	}
+	static int Polycode_SceneMesh_setSkeleton(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneMesh *inst = (SceneMesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Skeleton* skeleton = (Skeleton*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setSkeleton(skeleton);
+		return 0;
+	}
+	static int Polycode_SceneMesh_getSkeleton(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneMesh *inst = (SceneMesh*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getSkeleton();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneMesh_applySkeletonLocally(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneMesh *inst = (SceneMesh*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->applySkeletonLocally();
+		return 0;
+	}
+	static int Polycode_SceneMesh_setLineWidth(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneMesh *inst = (SceneMesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number newWidth = lua_tonumber(L, 2);
+		inst->setLineWidth(newWidth);
+		return 0;
+	}
+	static int Polycode_SceneMesh_getFilename(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneMesh *inst = (SceneMesh*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushstring(L, inst->getFilename().c_str());
+		return 1;
+	}
+	static int Polycode_SceneMesh_setFilename(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneMesh *inst = (SceneMesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 2));
+		inst->setFilename(fileName);
+		return 0;
+	}
+	static int Polycode_SceneMesh_loadFromFile(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneMesh *inst = (SceneMesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 2));
+		inst->loadFromFile(fileName);
+		return 0;
+	}
+	static int Polycode_SceneMesh_customHitDetection(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneMesh *inst = (SceneMesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Ray ray = *(Ray*) *((PolyBase**)lua_touserdata(L, 2));
+		lua_pushboolean(L, inst->customHitDetection(ray));
+		return 1;
+	}
+	static int Polycode_SceneMesh_setForceMaterial(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneMesh *inst = (SceneMesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool forceMaterial = lua_toboolean(L, 2) != 0;
+		inst->setForceMaterial(forceMaterial);
+		return 0;
+	}
+	static int Polycode_SceneMesh_getForceMaterial(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneMesh *inst = (SceneMesh*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->getForceMaterial());
+		return 1;
+	}
+	static int Polycode_SceneMesh_Clone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneMesh *inst = (SceneMesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool deepClone = lua_toboolean(L, 2) != 0;
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool ignoreEditorOnly = lua_toboolean(L, 3) != 0;
+		PolyBase *ptrRetVal = (PolyBase*)inst->Clone(deepClone, ignoreEditorOnly);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneMesh_applyClone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneMesh *inst = (SceneMesh*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Entity* clone = (Entity*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool deepClone = lua_toboolean(L, 3) != 0;
+		luaL_checktype(L, 4, LUA_TBOOLEAN);
+		bool ignoreEditorOnly = lua_toboolean(L, 4) != 0;
+		inst->applyClone(clone, deepClone, ignoreEditorOnly);
+		return 0;
+	}
+	static int Polycode_ScenePrimitive(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TNUMBER);
+		int type = lua_tointeger(L, 1);
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number v1 = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number v2 = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number v3 = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number v4 = lua_tonumber(L, 5);
+		luaL_checktype(L, 6, LUA_TNUMBER);
+		Number v5 = lua_tonumber(L, 6);
+		ScenePrimitive *inst = new ScenePrimitive(type, v1, v2, v3, v4, v5);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.ScenePrimitive");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_ScenePrimitive_setPrimitiveOptions(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ScenePrimitive *inst = (ScenePrimitive*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int type = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number v1 = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number v2 = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number v3 = lua_tonumber(L, 5);
+		luaL_checktype(L, 6, LUA_TNUMBER);
+		Number v4 = lua_tonumber(L, 6);
+		luaL_checktype(L, 7, LUA_TNUMBER);
+		Number v5 = lua_tonumber(L, 7);
+		inst->setPrimitiveOptions(type, v1, v2, v3, v4, v5);
+		return 0;
+	}
+	static int Polycode_ScenePrimitive_recreatePrimitive(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ScenePrimitive *inst = (ScenePrimitive*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->recreatePrimitive();
+		return 0;
+	}
+	static int Polycode_ScenePrimitive_getPrimitiveType(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ScenePrimitive *inst = (ScenePrimitive*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getPrimitiveType());
+		return 1;
+	}
+	static int Polycode_ScenePrimitive_getPrimitiveParameter1(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ScenePrimitive *inst = (ScenePrimitive*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getPrimitiveParameter1());
+		return 1;
+	}
+	static int Polycode_ScenePrimitive_getPrimitiveParameter2(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ScenePrimitive *inst = (ScenePrimitive*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getPrimitiveParameter2());
+		return 1;
+	}
+	static int Polycode_ScenePrimitive_getPrimitiveParameter3(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ScenePrimitive *inst = (ScenePrimitive*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getPrimitiveParameter3());
+		return 1;
+	}
+	static int Polycode_ScenePrimitive_getPrimitiveParameter4(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ScenePrimitive *inst = (ScenePrimitive*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getPrimitiveParameter4());
+		return 1;
+	}
+	static int Polycode_ScenePrimitive_getPrimitiveParameter5(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ScenePrimitive *inst = (ScenePrimitive*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getPrimitiveParameter5());
+		return 1;
+	}
+	static int Polycode_ScenePrimitive_Clone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ScenePrimitive *inst = (ScenePrimitive*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool deepClone = lua_toboolean(L, 2) != 0;
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool ignoreEditorOnly = lua_toboolean(L, 3) != 0;
+		PolyBase *ptrRetVal = (PolyBase*)inst->Clone(deepClone, ignoreEditorOnly);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_ScenePrimitive_applyClone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ScenePrimitive *inst = (ScenePrimitive*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Entity* clone = (Entity*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool deepClone = lua_toboolean(L, 3) != 0;
+		luaL_checktype(L, 4, LUA_TBOOLEAN);
+		bool ignoreEditorOnly = lua_toboolean(L, 4) != 0;
+		inst->applyClone(clone, deepClone, ignoreEditorOnly);
+		return 0;
+	}
+	static int Polycode_SceneRenderTexture(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Scene* targetScene = (Scene*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Camera* targetCamera = (Camera*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int renderWidth = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int renderHeight = lua_tointeger(L, 4);
+		luaL_checktype(L, 5, LUA_TBOOLEAN);
+		bool floatingPoint = lua_toboolean(L, 5) != 0;
+		SceneRenderTexture *inst = new SceneRenderTexture(targetScene, targetCamera, renderWidth, renderHeight, floatingPoint);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.SceneRenderTexture");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_SceneRenderTexture_getTargetTexture(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneRenderTexture *inst = (SceneRenderTexture*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getTargetTexture();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneRenderTexture_getFilterColorBufferTexture(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneRenderTexture *inst = (SceneRenderTexture*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getFilterColorBufferTexture();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneRenderTexture_getFilterZBufferTexture(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneRenderTexture *inst = (SceneRenderTexture*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getFilterZBufferTexture();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneRenderTexture_Render(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneRenderTexture *inst = (SceneRenderTexture*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->Render();
+		return 0;
+	}
+	static int Polycode_SceneRenderTexture_saveToImage(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneRenderTexture *inst = (SceneRenderTexture*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->saveToImage();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneRenderTexture_resizeRenderTexture(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneRenderTexture *inst = (SceneRenderTexture*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int newWidth = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int newHeight = lua_tointeger(L, 3);
+		inst->resizeRenderTexture(newWidth, newHeight);
+		return 0;
+	}
+	static int Polycode_SceneRenderTexture_getTargetScene(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneRenderTexture *inst = (SceneRenderTexture*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getTargetScene();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneRenderTexture_getTargetCamera(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneRenderTexture *inst = (SceneRenderTexture*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getTargetCamera();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneSound(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number referenceDistance = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number maxDistance = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TBOOLEAN);
+		bool directionalSound = lua_toboolean(L, 4) != 0;
+		SceneSound *inst = new SceneSound(fileName, referenceDistance, maxDistance, directionalSound);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.SceneSound");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_SceneSound_Update(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneSound *inst = (SceneSound*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->Update();
+		return 0;
+	}
+	static int Polycode_SceneSound_Clone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneSound *inst = (SceneSound*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool deepClone = lua_toboolean(L, 2) != 0;
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool ignoreEditorOnly = lua_toboolean(L, 3) != 0;
+		PolyBase *ptrRetVal = (PolyBase*)inst->Clone(deepClone, ignoreEditorOnly);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneSound_applyClone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneSound *inst = (SceneSound*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Entity* clone = (Entity*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool deepClone = lua_toboolean(L, 3) != 0;
+		luaL_checktype(L, 4, LUA_TBOOLEAN);
+		bool ignoreEditorOnly = lua_toboolean(L, 4) != 0;
+		inst->applyClone(clone, deepClone, ignoreEditorOnly);
+		return 0;
+	}
+	static int Polycode_SceneSound_isDirectionalSound(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneSound *inst = (SceneSound*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->isDirectionalSound());
+		return 1;
+	}
+	static int Polycode_SceneSound_setDirectionalSound(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneSound *inst = (SceneSound*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool val = lua_toboolean(L, 2) != 0;
+		inst->setDirectionalSound(val);
+		return 0;
+	}
+	static int Polycode_SceneSound_getSound(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneSound *inst = (SceneSound*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getSound();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneSound_setLoopOnLoad(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneSound *inst = (SceneSound*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool val = lua_toboolean(L, 2) != 0;
+		inst->setLoopOnLoad(val);
+		return 0;
+	}
+	static int Polycode_SceneSound_getLoopOnLoad(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneSound *inst = (SceneSound*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->getLoopOnLoad());
+		return 1;
+	}
+	static int Polycode_SceneSoundListener(lua_State *L) {
+		SceneSoundListener *inst = new SceneSoundListener();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.SceneSoundListener");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_SceneSoundListener_Update(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneSoundListener *inst = (SceneSoundListener*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->Update();
+		return 0;
+	}
+	static int Polycode_SceneSprite(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteSet* spriteSet = (SpriteSet*) *((PolyBase**)lua_touserdata(L, 1));
+		SceneSprite *inst = new SceneSprite(spriteSet);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.SceneSprite");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_SceneSprite_Clone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneSprite *inst = (SceneSprite*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool deepClone = lua_toboolean(L, 2) != 0;
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool ignoreEditorOnly = lua_toboolean(L, 3) != 0;
+		PolyBase *ptrRetVal = (PolyBase*)inst->Clone(deepClone, ignoreEditorOnly);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneSprite_applyClone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneSprite *inst = (SceneSprite*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Entity* clone = (Entity*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool deepClone = lua_toboolean(L, 3) != 0;
+		luaL_checktype(L, 4, LUA_TBOOLEAN);
+		bool ignoreEditorOnly = lua_toboolean(L, 4) != 0;
+		inst->applyClone(clone, deepClone, ignoreEditorOnly);
+		return 0;
+	}
+	static int Polycode_SceneSprite_getSpriteSet(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneSprite *inst = (SceneSprite*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getSpriteSet();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneSprite_getCurrentSprite(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneSprite *inst = (SceneSprite*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getCurrentSprite();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneSprite_setSpriteSet(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneSprite *inst = (SceneSprite*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		SpriteSet* spriteSet = (SpriteSet*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setSpriteSet(spriteSet);
+		return 0;
+	}
+	static int Polycode_SceneSprite_setSpriteByName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneSprite *inst = (SceneSprite*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String spriteName = String(lua_tostring(L, 2));
+		inst->setSpriteByName(spriteName);
+		return 0;
+	}
+	static int Polycode_SceneSprite_setCurrentFrame(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneSprite *inst = (SceneSprite*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int frameIndex = lua_tointeger(L, 2);
+		inst->setCurrentFrame(frameIndex);
+		return 0;
+	}
+	static int Polycode_SceneSprite_getCurrentFrame(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneSprite *inst = (SceneSprite*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getCurrentFrame());
+		return 1;
+	}
+	static int Polycode_SceneSprite_Update(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneSprite *inst = (SceneSprite*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->Update();
+		return 0;
+	}
+	static int Polycode_SceneSprite_Render(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneSprite *inst = (SceneSprite*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		GPUDrawBuffer* buffer = (GPUDrawBuffer*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->Render(buffer);
+		return 0;
+	}
+	static int Polycode_SceneSprite_getSpriteBoundingBox(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneSprite *inst = (SceneSprite*) *((PolyBase**)lua_touserdata(L, 1));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->getSpriteBoundingBox();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_SceneSprite_setPaused(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneSprite *inst = (SceneSprite*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool val = lua_toboolean(L, 2) != 0;
+		inst->setPaused(val);
+		return 0;
+	}
+	static int Polycode_SceneSprite_isPaused(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneSprite *inst = (SceneSprite*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->isPaused());
+		return 1;
+	}
+	static int Polycode_SceneSprite_setSprite(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneSprite *inst = (SceneSprite*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Sprite* spriteEntry = (Sprite*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setSprite(spriteEntry);
+		return 0;
+	}
+	static int Polycode_SceneSprite_setSpriteState(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneSprite *inst = (SceneSprite*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		SpriteState* spriteState = (SpriteState*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int startingFrame = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TBOOLEAN);
+		bool playOnce = lua_toboolean(L, 4) != 0;
+		inst->setSpriteState(spriteState, startingFrame, playOnce);
+		return 0;
+	}
+	static int Polycode_SceneSprite_setSpriteStateByName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneSprite *inst = (SceneSprite*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String name = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int startingFrame = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TBOOLEAN);
+		bool playOnce = lua_toboolean(L, 4) != 0;
+		inst->setSpriteStateByName(name, startingFrame, playOnce);
+		return 0;
+	}
+	static int Polycode_SceneSprite_getCurrentSpriteState(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneSprite *inst = (SceneSprite*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getCurrentSpriteState();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SceneSprite_getStartOnRandomFrame(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneSprite *inst = (SceneSprite*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->getStartOnRandomFrame());
+		return 1;
+	}
+	static int Polycode_SceneSprite_setStartOnRandomFrame(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SceneSprite *inst = (SceneSprite*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool val = lua_toboolean(L, 2) != 0;
+		inst->setStartOnRandomFrame(val);
+		return 0;
+	}
+	static int Polycode_Sprite(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TSTRING);
+		String name = String(lua_tostring(L, 1));
+		Sprite *inst = new Sprite(name);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.Sprite");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Sprite_getName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sprite *inst = (Sprite*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushstring(L, inst->getName().c_str());
+		return 1;
+	}
+	static int Polycode_Sprite_setName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sprite *inst = (Sprite*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String name = String(lua_tostring(L, 2));
+		inst->setName(name);
+		return 0;
+	}
+	static int Polycode_Sprite_addSpriteState(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sprite *inst = (Sprite*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		SpriteState* state = (SpriteState*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->addSpriteState(state);
+		return 0;
+	}
+	static int Polycode_Sprite_removeSpriteState(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sprite *inst = (Sprite*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		SpriteState* state = (SpriteState*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->removeSpriteState(state);
+		return 0;
+	}
+	static int Polycode_Sprite_getNumStates(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sprite *inst = (Sprite*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getNumStates());
+		return 1;
+	}
+	static int Polycode_Sprite_getState(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sprite *inst = (Sprite*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->getState(index);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Sprite_getStateByName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sprite *inst = (Sprite*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String name = String(lua_tostring(L, 2));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getStateByName(name);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Sprite_setParentSpritSet(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sprite *inst = (Sprite*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		SpriteSet* spriteSet = (SpriteSet*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setParentSpritSet(spriteSet);
+		return 0;
+	}
+	static int Polycode_Sprite_getParentSpriteSet(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sprite *inst = (Sprite*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getParentSpriteSet();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SpriteSet(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ResourcePool* parentPool = (ResourcePool*) *((PolyBase**)lua_touserdata(L, 2));
+		SpriteSet *inst = new SpriteSet(fileName, parentPool);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.SpriteSet");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_SpriteSet_setTexture(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteSet *inst = (SpriteSet*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Texture* texture = (Texture*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setTexture(texture);
+		return 0;
+	}
+	static int Polycode_SpriteSet_getTexture(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteSet *inst = (SpriteSet*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getTexture();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SpriteSet_loadTexture(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteSet *inst = (SpriteSet*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String imageFileName = String(lua_tostring(L, 2));
+		PolyBase *ptrRetVal = (PolyBase*)inst->loadTexture(imageFileName);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SpriteSet_addSpriteEntry(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteSet *inst = (SpriteSet*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Sprite* newEntry = (Sprite*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->addSpriteEntry(newEntry);
+		return 0;
+	}
+	static int Polycode_SpriteSet_getNumSpriteEntries(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteSet *inst = (SpriteSet*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getNumSpriteEntries());
+		return 1;
+	}
+	static int Polycode_SpriteSet_getSpriteEntry(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteSet *inst = (SpriteSet*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->getSpriteEntry(index);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SpriteSet_removeSprite(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteSet *inst = (SpriteSet*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Sprite* sprite = (Sprite*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->removeSprite(sprite);
+		return 0;
+	}
+	static int Polycode_SpriteSet_loadSpriteSet(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteSet *inst = (SpriteSet*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 2));
+		inst->loadSpriteSet(fileName);
+		return 0;
+	}
+	static int Polycode_SpriteSet_addSpriteFrame(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteSet *inst = (SpriteSet*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		SpriteFrame frame = *(SpriteFrame*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool assignID = lua_toboolean(L, 3) != 0;
+		inst->addSpriteFrame(frame, assignID);
+		return 0;
+	}
+	static int Polycode_SpriteSet_getNumFrames(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteSet *inst = (SpriteSet*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getNumFrames());
+		return 1;
+	}
+	static int Polycode_SpriteSet_getSpriteFrame(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteSet *inst = (SpriteSet*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		SpriteFrame *retInst = new SpriteFrame();
+		*retInst = inst->getSpriteFrame(index);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.SpriteFrame");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_SpriteSet_getSpriteFrameByID(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteSet *inst = (SpriteSet*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int frameID = lua_tointeger(L, 2);
+		SpriteFrame *retInst = new SpriteFrame();
+		*retInst = inst->getSpriteFrameByID(frameID);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.SpriteFrame");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_SpriteSet_removeFrameByID(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteSet *inst = (SpriteSet*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int frameID = lua_tointeger(L, 2);
+		inst->removeFrameByID(frameID);
+		return 0;
+	}
+	static int Polycode_SpriteSet_setSpriteFrame(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteSet *inst = (SpriteSet*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		SpriteFrame frame = *(SpriteFrame*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setSpriteFrame(frame);
+		return 0;
+	}
+	static int Polycode_SpriteSet_clearFrames(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteSet *inst = (SpriteSet*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->clearFrames();
+		return 0;
+	}
+	static int Polycode_SpriteSet_createGridFrames(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteSet *inst = (SpriteSet*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int xCount = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int yCount = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		Vector2 defaultAnchor = *(Vector2*) *((PolyBase**)lua_touserdata(L, 4));
+		inst->createGridFrames(xCount, yCount, defaultAnchor);
+		return 0;
+	}
+	static int Polycode_SpriteSet_createFramesFromIslands(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteSet *inst = (SpriteSet*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int minDistance = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Vector2 defaultAnchor = *(Vector2*) *((PolyBase**)lua_touserdata(L, 3));
+		inst->createFramesFromIslands(minDistance, defaultAnchor);
+		return 0;
+	}
+	static int Polycode_SpriteSet_getSpriteByName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteSet *inst = (SpriteSet*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String spriteName = String(lua_tostring(L, 2));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getSpriteByName(spriteName);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SpriteState(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteSet* spriteSet = (SpriteSet*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String name = String(lua_tostring(L, 2));
+		SpriteState *inst = new SpriteState(spriteSet, name);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.SpriteState");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_SpriteState_setName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteState *inst = (SpriteState*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String name = String(lua_tostring(L, 2));
+		inst->setName(name);
+		return 0;
+	}
+	static int Polycode_SpriteState_getName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteState *inst = (SpriteState*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushstring(L, inst->getName().c_str());
+		return 1;
+	}
+	static int Polycode_SpriteState_getNumFrameIDs(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteState *inst = (SpriteState*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getNumFrameIDs());
+		return 1;
+	}
+	static int Polycode_SpriteState_getFrameIDAtIndex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteState *inst = (SpriteState*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		lua_pushinteger(L, inst->getFrameIDAtIndex(index));
+		return 1;
+	}
+	static int Polycode_SpriteState_getMeshForFrameIndex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteState *inst = (SpriteState*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->getMeshForFrameIndex(index);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SpriteState_insertFrame(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteState *inst = (SpriteState*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int frameID = lua_tointeger(L, 3);
+		inst->insertFrame(index, frameID);
+		return 0;
+	}
+	static int Polycode_SpriteState_removeFrameByIndex(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteState *inst = (SpriteState*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int frameIndex = lua_tointeger(L, 2);
+		inst->removeFrameByIndex(frameIndex);
+		return 0;
+	}
+	static int Polycode_SpriteState_clearFrames(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteState *inst = (SpriteState*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->clearFrames();
+		return 0;
+	}
+	static int Polycode_SpriteState_setPixelsPerUnit(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteState *inst = (SpriteState*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number ppu = lua_tonumber(L, 2);
+		inst->setPixelsPerUnit(ppu);
+		return 0;
+	}
+	static int Polycode_SpriteState_getPixelsPerUnit(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteState *inst = (SpriteState*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getPixelsPerUnit());
+		return 1;
+	}
+	static int Polycode_SpriteState_rebuildStateMeshes(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteState *inst = (SpriteState*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->rebuildStateMeshes();
+		return 0;
+	}
+	static int Polycode_SpriteState_setStateFPS(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteState *inst = (SpriteState*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number fps = lua_tonumber(L, 2);
+		inst->setStateFPS(fps);
+		return 0;
+	}
+	static int Polycode_SpriteState_getStateFPS(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteState *inst = (SpriteState*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getStateFPS());
+		return 1;
+	}
+	static int Polycode_SpriteState_getLargestFrameBoundingBox(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteState *inst = (SpriteState*) *((PolyBase**)lua_touserdata(L, 1));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->getLargestFrameBoundingBox();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_SpriteState_setBoundingBox(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteState *inst = (SpriteState*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector2 boundingBox = *(Vector2*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setBoundingBox(boundingBox);
+		return 0;
+	}
+	static int Polycode_SpriteState_getBoundingBox(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteState *inst = (SpriteState*) *((PolyBase**)lua_touserdata(L, 1));
+		Vector2 *retInst = new Vector2();
+		*retInst = inst->getBoundingBox();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector2");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_SpriteState_getSpriteOffset(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteState *inst = (SpriteState*) *((PolyBase**)lua_touserdata(L, 1));
+		Vector2 *retInst = new Vector2();
+		*retInst = inst->getSpriteOffset();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector2");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_SpriteState_setSpriteOffset(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SpriteState *inst = (SpriteState*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector2 offset = *(Vector2*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setSpriteOffset(offset);
+		return 0;
+	}
+	static int Polycode_ProgramParam(lua_State *L) {
+		ProgramParam *inst = new ProgramParam();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.ProgramParam");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_ProgramParam_createParamData(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ProgramParam *inst = (ProgramParam*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int type = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->createParamData(type);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_ProgramAttribute(lua_State *L) {
+		ProgramAttribute *inst = new ProgramAttribute();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.ProgramAttribute");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_ShaderRenderTarget(lua_State *L) {
+		ShaderRenderTarget *inst = new ShaderRenderTarget();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.ShaderRenderTarget");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Shader_getType(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Shader *inst = (Shader*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getType());
+		return 1;
+	}
+	static int Polycode_Shader_setName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Shader *inst = (Shader*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String name = String(lua_tostring(L, 2));
+		inst->setName(name);
+		return 0;
+	}
+	static int Polycode_Shader_getName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Shader *inst = (Shader*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushstring(L, inst->getName().c_str());
+		return 1;
+	}
+	static int Polycode_Shader_getParamPointer(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Shader *inst = (Shader*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String name = String(lua_tostring(L, 2));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getParamPointer(name);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Shader_getAttribPointer(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Shader *inst = (Shader*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String name = String(lua_tostring(L, 2));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getAttribPointer(name);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Shader_reload(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Shader *inst = (Shader*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->reload();
+		return 0;
+	}
+	static int Polycode_Shader_getExpectedParamType(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Shader *inst = (Shader*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String name = String(lua_tostring(L, 2));
+		lua_pushinteger(L, inst->getExpectedParamType(name));
+		return 1;
+	}
+	static int Polycode_Shader_setVertexProgram(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Shader *inst = (Shader*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ShaderProgram* vp = (ShaderProgram*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setVertexProgram(vp);
+		return 0;
+	}
+	static int Polycode_Shader_setFragmentProgram(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Shader *inst = (Shader*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ShaderProgram* fp = (ShaderProgram*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setFragmentProgram(fp);
+		return 0;
+	}
+	static int Polycode_LocalShaderParam(lua_State *L) {
+		LocalShaderParam *inst = new LocalShaderParam();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.LocalShaderParam");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_LocalShaderParam_Copy(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		LocalShaderParam *inst = (LocalShaderParam*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->Copy();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_LocalShaderParam_getNumber(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		LocalShaderParam *inst = (LocalShaderParam*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getNumber());
+		return 1;
+	}
+	static int Polycode_LocalShaderParam_getVector2(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		LocalShaderParam *inst = (LocalShaderParam*) *((PolyBase**)lua_touserdata(L, 1));
+		Vector2 *retInst = new Vector2();
+		*retInst = inst->getVector2();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector2");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_LocalShaderParam_getVector3(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		LocalShaderParam *inst = (LocalShaderParam*) *((PolyBase**)lua_touserdata(L, 1));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->getVector3();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_LocalShaderParam_getMatrix4(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		LocalShaderParam *inst = (LocalShaderParam*) *((PolyBase**)lua_touserdata(L, 1));
+		Matrix4 *retInst = new Matrix4();
+		*retInst = inst->getMatrix4();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Matrix4");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_LocalShaderParam_getColor(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		LocalShaderParam *inst = (LocalShaderParam*) *((PolyBase**)lua_touserdata(L, 1));
+		Color *retInst = new Color();
+		*retInst = inst->getColor();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Color");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_LocalShaderParam_setNumber(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		LocalShaderParam *inst = (LocalShaderParam*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 2);
+		inst->setNumber(x);
+		return 0;
+	}
+	static int Polycode_LocalShaderParam_setVector2(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		LocalShaderParam *inst = (LocalShaderParam*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector2 x = *(Vector2*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setVector2(x);
+		return 0;
+	}
+	static int Polycode_LocalShaderParam_setVector3(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		LocalShaderParam *inst = (LocalShaderParam*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 x = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setVector3(x);
+		return 0;
+	}
+	static int Polycode_LocalShaderParam_setMatrix4(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		LocalShaderParam *inst = (LocalShaderParam*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Matrix4 x = *(Matrix4*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setMatrix4(x);
+		return 0;
+	}
+	static int Polycode_LocalShaderParam_setColor(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		LocalShaderParam *inst = (LocalShaderParam*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Color x = *(Color*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setColor(x);
+		return 0;
+	}
+	static int Polycode_LocalShaderParam_setTexture(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		LocalShaderParam *inst = (LocalShaderParam*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Texture* texture = (Texture*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setTexture(texture);
+		return 0;
+	}
+	static int Polycode_LocalShaderParam_getTexture(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		LocalShaderParam *inst = (LocalShaderParam*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getTexture();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_LocalShaderParam_setCubemap(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		LocalShaderParam *inst = (LocalShaderParam*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Cubemap* cubemap = (Cubemap*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setCubemap(cubemap);
+		return 0;
+	}
+	static int Polycode_LocalShaderParam_getCubemap(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		LocalShaderParam *inst = (LocalShaderParam*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getCubemap();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_LocalShaderParam_setParamValueFromString(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		LocalShaderParam *inst = (LocalShaderParam*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int type = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String pvalue = String(lua_tostring(L, 3));
+		inst->setParamValueFromString(type, pvalue);
+		return 0;
+	}
+	static int Polycode_ShaderProgram(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 1));
+		ShaderProgram *inst = new ShaderProgram(fileName);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.ShaderProgram");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_ShaderProgram_reloadProgram(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderProgram *inst = (ShaderProgram*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->reloadProgram();
+		return 0;
+	}
+	static int Polycode_ShaderProgram_reloadResource(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderProgram *inst = (ShaderProgram*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->reloadResource();
+		return 0;
+	}
+	static int Polycode_AttributeBinding(lua_State *L) {
+		AttributeBinding *inst = new AttributeBinding();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.AttributeBinding");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_ShaderBinding(lua_State *L) {
+		ShaderBinding *inst = new ShaderBinding();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.ShaderBinding");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_ShaderBinding_copyTo(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderBinding *inst = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		ShaderBinding* targetBinding = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->copyTo(targetBinding);
+		return 0;
+	}
+	static int Polycode_ShaderBinding_addParam(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderBinding *inst = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int type = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String name = String(lua_tostring(L, 3));
+		PolyBase *ptrRetVal = (PolyBase*)inst->addParam(type, name);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_ShaderBinding_addParamPointer(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderBinding *inst = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int type = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String name = String(lua_tostring(L, 3));
+		luaL_checktype(L, 4, LUA_TUSERDATA);
+		void* ptr = (void*) *((PolyBase**)lua_touserdata(L, 4));
+		PolyBase *ptrRetVal = (PolyBase*)inst->addParamPointer(type, name, ptr);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_ShaderBinding_getNumLocalParams(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderBinding *inst = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getNumLocalParams());
+		return 1;
+	}
+	static int Polycode_ShaderBinding_getLocalParam(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderBinding *inst = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->getLocalParam(index);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_ShaderBinding_getLocalParamByName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderBinding *inst = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String name = String(lua_tostring(L, 2));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getLocalParamByName(name);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_ShaderBinding_removeParam(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderBinding *inst = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String name = String(lua_tostring(L, 2));
+		inst->removeParam(name);
+		return 0;
+	}
+	static int Polycode_ShaderBinding_loadTextureForParam(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderBinding *inst = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String paramName = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 3));
+		PolyBase *ptrRetVal = (PolyBase*)inst->loadTextureForParam(paramName, fileName);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_ShaderBinding_setTextureForParam(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderBinding *inst = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String paramName = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Texture* texture = (Texture*) *((PolyBase**)lua_touserdata(L, 3));
+		inst->setTextureForParam(paramName, texture);
+		return 0;
+	}
+	static int Polycode_ShaderBinding_setCubemapForParam(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderBinding *inst = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String paramName = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Cubemap* cubemap = (Cubemap*) *((PolyBase**)lua_touserdata(L, 3));
+		inst->setCubemapForParam(paramName, cubemap);
+		return 0;
+	}
+	static int Polycode_ShaderBinding_getNumAttributeBindings(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderBinding *inst = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getNumAttributeBindings());
+		return 1;
+	}
+	static int Polycode_ShaderBinding_getAttributeBinding(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderBinding *inst = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->getAttributeBinding(index);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_ShaderBinding_addAttributeBinding(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderBinding *inst = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String name = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		VertexDataArray* dataArray = (VertexDataArray*) *((PolyBase**)lua_touserdata(L, 3));
+		PolyBase *ptrRetVal = (PolyBase*)inst->addAttributeBinding(name, dataArray);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_ShaderBinding_getAttributeBindingByName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderBinding *inst = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String name = String(lua_tostring(L, 2));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getAttributeBindingByName(name);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_ShaderBinding_addRenderTargetBinding(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderBinding *inst = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		RenderTargetBinding* binding = (RenderTargetBinding*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->addRenderTargetBinding(binding);
+		return 0;
+	}
+	static int Polycode_ShaderBinding_removeRenderTargetBinding(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderBinding *inst = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		RenderTargetBinding* binding = (RenderTargetBinding*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->removeRenderTargetBinding(binding);
+		return 0;
+	}
+	static int Polycode_ShaderBinding_getNumRenderTargetBindings(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderBinding *inst = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getNumRenderTargetBindings());
+		return 1;
+	}
+	static int Polycode_ShaderBinding_getRenderTargetBinding(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderBinding *inst = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->getRenderTargetBinding(index);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_ShaderBinding_getNumInTargetBindings(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderBinding *inst = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getNumInTargetBindings());
+		return 1;
+	}
+	static int Polycode_ShaderBinding_getInTargetBinding(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderBinding *inst = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->getInTargetBinding(index);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_ShaderBinding_getNumColorTargetBindings(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderBinding *inst = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getNumColorTargetBindings());
+		return 1;
+	}
+	static int Polycode_ShaderBinding_getColorTargetBinding(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderBinding *inst = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->getColorTargetBinding(index);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_ShaderBinding_getNumDepthTargetBindings(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderBinding *inst = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getNumDepthTargetBindings());
+		return 1;
+	}
+	static int Polycode_ShaderBinding_getDepthTargetBinding(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderBinding *inst = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->getDepthTargetBinding(index);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_ShaderBinding_getNumOutTargetBindings(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderBinding *inst = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getNumOutTargetBindings());
+		return 1;
+	}
+	static int Polycode_ShaderBinding_getOutTargetBinding(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		ShaderBinding *inst = (ShaderBinding*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->getOutTargetBinding(index);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SkeletonAnimation(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TSTRING);
+		String name = String(lua_tostring(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number duration = lua_tonumber(L, 2);
+		SkeletonAnimation *inst = new SkeletonAnimation(name, duration);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.SkeletonAnimation");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_SkeletonAnimation_addBoneTrack(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SkeletonAnimation *inst = (SkeletonAnimation*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		BoneTrack* boneTrack = (BoneTrack*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->addBoneTrack(boneTrack);
+		return 0;
+	}
+	static int Polycode_SkeletonAnimation_getName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SkeletonAnimation *inst = (SkeletonAnimation*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushstring(L, inst->getName().c_str());
+		return 1;
+	}
+	static int Polycode_SkeletonAnimation_Play(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SkeletonAnimation *inst = (SkeletonAnimation*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool once = lua_toboolean(L, 2) != 0;
+		inst->Play(once);
+		return 0;
+	}
+	static int Polycode_SkeletonAnimation_Stop(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SkeletonAnimation *inst = (SkeletonAnimation*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->Stop();
+		return 0;
+	}
+	static int Polycode_SkeletonAnimation_Reset(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SkeletonAnimation *inst = (SkeletonAnimation*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->Reset();
+		return 0;
+	}
+	static int Polycode_SkeletonAnimation_Update(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SkeletonAnimation *inst = (SkeletonAnimation*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->Update();
+		return 0;
+	}
+	static int Polycode_SkeletonAnimation_setSpeed(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SkeletonAnimation *inst = (SkeletonAnimation*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number speed = lua_tonumber(L, 2);
+		inst->setSpeed(speed);
+		return 0;
+	}
+	static int Polycode_SkeletonAnimation_setWeight(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SkeletonAnimation *inst = (SkeletonAnimation*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number newWeight = lua_tonumber(L, 2);
+		inst->setWeight(newWeight);
+		return 0;
+	}
+	static int Polycode_SkeletonAnimation_getWeight(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SkeletonAnimation *inst = (SkeletonAnimation*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getWeight());
+		return 1;
+	}
+	static int Polycode_SkeletonAnimation_isPlaying(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SkeletonAnimation *inst = (SkeletonAnimation*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->isPlaying());
+		return 1;
+	}
+	static int Polycode_Skeleton(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 1));
+		Skeleton *inst = new Skeleton(fileName);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.Skeleton");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Skeleton_BlankSkeleton(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Skeleton *inst = (Skeleton*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->BlankSkeleton();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Skeleton_loadSkeleton(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Skeleton *inst = (Skeleton*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 2));
+		inst->loadSkeleton(fileName);
+		return 0;
+	}
+	static int Polycode_Skeleton_playAnimationByName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Skeleton *inst = (Skeleton*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String animName = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number weight = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TBOOLEAN);
+		bool once = lua_toboolean(L, 4) != 0;
+		luaL_checktype(L, 5, LUA_TBOOLEAN);
+		bool restartIfPlaying = lua_toboolean(L, 5) != 0;
+		inst->playAnimationByName(animName, weight, once, restartIfPlaying);
+		return 0;
+	}
+	static int Polycode_Skeleton_playAnimation(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Skeleton *inst = (Skeleton*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		SkeletonAnimation* animation = (SkeletonAnimation*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number weight = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TBOOLEAN);
+		bool once = lua_toboolean(L, 4) != 0;
+		luaL_checktype(L, 5, LUA_TBOOLEAN);
+		bool restartIfPlaying = lua_toboolean(L, 5) != 0;
+		inst->playAnimation(animation, weight, once, restartIfPlaying);
+		return 0;
+	}
+	static int Polycode_Skeleton_setBaseAnimationByName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Skeleton *inst = (Skeleton*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String animName = String(lua_tostring(L, 2));
+		inst->setBaseAnimationByName(animName);
+		return 0;
+	}
+	static int Polycode_Skeleton_setBaseAnimation(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Skeleton *inst = (Skeleton*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		SkeletonAnimation* animation = (SkeletonAnimation*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setBaseAnimation(animation);
+		return 0;
+	}
+	static int Polycode_Skeleton_stopAllAnimations(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Skeleton *inst = (Skeleton*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->stopAllAnimations();
+		return 0;
+	}
+	static int Polycode_Skeleton_getBaseAnimation(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Skeleton *inst = (Skeleton*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getBaseAnimation();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Skeleton_addAnimation(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Skeleton *inst = (Skeleton*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String name = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 3));
+		inst->addAnimation(name, fileName);
+		return 0;
+	}
+	static int Polycode_Skeleton_getAnimation(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Skeleton *inst = (Skeleton*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String name = String(lua_tostring(L, 2));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getAnimation(name);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Skeleton_stopAnimationByName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Skeleton *inst = (Skeleton*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String name = String(lua_tostring(L, 2));
+		inst->stopAnimationByName(name);
+		return 0;
+	}
+	static int Polycode_Skeleton_stopAnimation(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Skeleton *inst = (Skeleton*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		SkeletonAnimation* animation = (SkeletonAnimation*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->stopAnimation(animation);
+		return 0;
+	}
+	static int Polycode_Skeleton_Update(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Skeleton *inst = (Skeleton*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->Update();
+		return 0;
+	}
+	static int Polycode_Skeleton_getBoneByName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Skeleton *inst = (Skeleton*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String name = String(lua_tostring(L, 2));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getBoneByName(name);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Skeleton_bonesVisible(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Skeleton *inst = (Skeleton*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool val = lua_toboolean(L, 2) != 0;
+		inst->bonesVisible(val);
+		return 0;
+	}
+	static int Polycode_Skeleton_getNumBones(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Skeleton *inst = (Skeleton*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getNumBones());
+		return 1;
+	}
+	static int Polycode_Skeleton_getBone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Skeleton *inst = (Skeleton*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int index = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->getBone(index);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Skeleton_addBone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Skeleton *inst = (Skeleton*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Bone* bone = (Bone*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->addBone(bone);
+		return 0;
+	}
+	static int Polycode_Skeleton_removeBone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Skeleton *inst = (Skeleton*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Bone* bone = (Bone*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->removeBone(bone);
+		return 0;
+	}
+	static int Polycode_Skeleton_getBoneIndexByBone(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Skeleton *inst = (Skeleton*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Bone* bone = (Bone*) *((PolyBase**)lua_touserdata(L, 2));
+		lua_pushinteger(L, inst->getBoneIndexByBone(bone));
+		return 1;
+	}
+	static int Polycode_BoneTrack(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Bone* bone = (Bone*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number length = lua_tonumber(L, 2);
+		BoneTrack *inst = new BoneTrack(bone, length);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.BoneTrack");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_BoneTrack_Play(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BoneTrack *inst = (BoneTrack*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool once = lua_toboolean(L, 2) != 0;
+		inst->Play(once);
+		return 0;
+	}
+	static int Polycode_BoneTrack_Stop(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BoneTrack *inst = (BoneTrack*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->Stop();
+		return 0;
+	}
+	static int Polycode_BoneTrack_Update(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BoneTrack *inst = (BoneTrack*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number elapsed = lua_tonumber(L, 2);
+		inst->Update(elapsed);
+		return 0;
+	}
+	static int Polycode_BoneTrack_Reset(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BoneTrack *inst = (BoneTrack*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->Reset();
+		return 0;
+	}
+	static int Polycode_BoneTrack_setSpeed(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		BoneTrack *inst = (BoneTrack*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number speed = lua_tonumber(L, 2);
+		inst->setSpeed(speed);
+		return 0;
+	}
+	static int Polycode_Sound(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 1));
+		Sound *inst = new Sound(fileName);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.Sound");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Sound_getSampleAsNumber(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int offset = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int channel = lua_tointeger(L, 3);
+		lua_pushnumber(L, inst->getSampleAsNumber(offset, channel));
+		return 1;
+	}
+	static int Polycode_Sound_loadFile(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 2));
+		inst->loadFile(fileName);
+		return 0;
+	}
+	static int Polycode_Sound_Play(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool loop = lua_toboolean(L, 2) != 0;
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool restartSound = lua_toboolean(L, 3) != 0;
+		inst->Play(loop, restartSound);
+		return 0;
+	}
+	static int Polycode_Sound_Stop(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->Stop();
+		return 0;
+	}
+	static int Polycode_Sound_setVolume(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number newVolume = lua_tonumber(L, 2);
+		inst->setVolume(newVolume);
+		return 0;
+	}
+	static int Polycode_Sound_getVolume(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getVolume());
+		return 1;
+	}
+	static int Polycode_Sound_setPitch(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number newPitch = lua_tonumber(L, 2);
+		inst->setPitch(newPitch);
+		return 0;
+	}
+	static int Polycode_Sound_getPitch(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getPitch());
+		return 1;
+	}
+	static int Polycode_Sound_isPlaying(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->isPlaying());
+		return 1;
+	}
+	static int Polycode_Sound_isLooped(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->isLooped());
+		return 1;
+	}
+	static int Polycode_Sound_setIsPositional(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool isPositional = lua_toboolean(L, 2) != 0;
+		inst->setIsPositional(isPositional);
+		return 0;
+	}
+	static int Polycode_Sound_setSoundPosition(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 position = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setSoundPosition(position);
+		return 0;
+	}
+	static int Polycode_Sound_setSoundVelocity(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 velocity = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setSoundVelocity(velocity);
+		return 0;
+	}
+	static int Polycode_Sound_setSoundDirection(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 direction = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setSoundDirection(direction);
+		return 0;
+	}
+	static int Polycode_Sound_setOffset(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int offset = lua_tointeger(L, 2);
+		inst->setOffset(offset);
+		return 0;
+	}
+	static int Polycode_Sound_getFileName(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushstring(L, inst->getFileName().c_str());
+		return 1;
+	}
+	static int Polycode_Sound_getPlaybackDuration(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getPlaybackDuration());
+		return 1;
+	}
+	static int Polycode_Sound_getPlaybackTime(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getPlaybackTime());
+		return 1;
+	}
+	static int Polycode_Sound_seekTo(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number time = lua_tonumber(L, 2);
+		inst->seekTo(time);
+		return 0;
+	}
+	static int Polycode_Sound_getOffset(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getOffset());
+		return 1;
+	}
+	static int Polycode_Sound_getSampleLength(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getSampleLength());
+		return 1;
+	}
+	static int Polycode_Sound_getFrequency(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getFrequency());
+		return 1;
+	}
+	static int Polycode_Sound_setPositionalProperties(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number referenceDistance = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number maxDistance = lua_tonumber(L, 3);
+		inst->setPositionalProperties(referenceDistance, maxDistance);
+		return 0;
+	}
+	static int Polycode_Sound_setReferenceDistance(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number referenceDistance = lua_tonumber(L, 2);
+		inst->setReferenceDistance(referenceDistance);
+		return 0;
+	}
+	static int Polycode_Sound_setMaxDistance(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number maxDistance = lua_tonumber(L, 2);
+		inst->setMaxDistance(maxDistance);
+		return 0;
+	}
+	static int Polycode_Sound_getReferenceDistance(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getReferenceDistance());
+		return 1;
+	}
+	static int Polycode_Sound_getMaxDistance(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getMaxDistance());
+		return 1;
+	}
+	static int Polycode_Sound_loadBytes(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		char* data = (char*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int size = lua_tointeger(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		int channels = lua_tointeger(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		int freq = lua_tointeger(L, 5);
+		luaL_checktype(L, 6, LUA_TUSERDATA);
+		SoundFormat format = *(SoundFormat*) *((PolyBase**)lua_touserdata(L, 6));
+		lua_pushboolean(L, inst->loadBytes(data, size, channels, freq, format));
+		return 1;
+	}
+	static int Polycode_Sound_loadWAV(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 2));
+		lua_pushboolean(L, inst->loadWAV(fileName));
+		return 1;
+	}
+	static int Polycode_Sound_loadOGG(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String fileName = String(lua_tostring(L, 2));
+		lua_pushboolean(L, inst->loadOGG(fileName));
+		return 1;
+	}
+	static int Polycode_Sound_soundCheck(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool result = lua_toboolean(L, 2) != 0;
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String err = String(lua_tostring(L, 3));
+		inst->soundCheck(result, err);
+		return 0;
+	}
+	static int Polycode_Sound_updateStream(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Sound *inst = (Sound*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int streamCount = lua_tointeger(L, 2);
+		inst->updateStream(streamCount);
+		return 0;
+	}
+	static int Polycode_AudioStreamingSource(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TNUMBER);
+		int channels = lua_tointeger(L, 1);
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int freq = lua_tointeger(L, 2);
+		AudioStreamingSource *inst = new AudioStreamingSource(channels, freq);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.AudioStreamingSource");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_AudioStreamingSource_getNumChannels(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		AudioStreamingSource *inst = (AudioStreamingSource*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getNumChannels());
+		return 1;
+	}
+	static int Polycode_AudioStreamingSource_getFrequency(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		AudioStreamingSource *inst = (AudioStreamingSource*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getFrequency());
+		return 1;
+	}
+	static int Polycode_AudioMixer(lua_State *L) {
+		AudioMixer *inst = new AudioMixer();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.AudioMixer");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_AudioMixer_mixIntoBuffer(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		AudioMixer *inst = (AudioMixer*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		int16_t* buffer = (int16_t*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int numSamples = lua_tointeger(L, 3);
+		inst->mixIntoBuffer(buffer, numSamples);
+		return 0;
+	}
+	static int Polycode_SoundManager(lua_State *L) {
+		SoundManager *inst = new SoundManager();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.SoundManager");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_SoundManager_setListenerPosition(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SoundManager *inst = (SoundManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 position = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setListenerPosition(position);
+		return 0;
+	}
+	static int Polycode_SoundManager_setListenerOrientation(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SoundManager *inst = (SoundManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 orientation = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		Vector3 upVector = *(Vector3*) *((PolyBase**)lua_touserdata(L, 3));
+		inst->setListenerOrientation(orientation, upVector);
+		return 0;
+	}
+	static int Polycode_SoundManager_recordSound(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SoundManager *inst = (SoundManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int rate = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int sampleSize = lua_tointeger(L, 3);
+		lua_pushboolean(L, inst->recordSound(rate, sampleSize));
+		return 1;
+	}
+	static int Polycode_SoundManager_stopRecording(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SoundManager *inst = (SoundManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool generateFloatBuffer = lua_toboolean(L, 2) != 0;
+		PolyBase *ptrRetVal = (PolyBase*)inst->stopRecording(generateFloatBuffer);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_SoundManager_setAudioInterface(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SoundManager *inst = (SoundManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		AudioInterface* audioInterface = (AudioInterface*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setAudioInterface(audioInterface);
+		return 0;
+	}
+	static int Polycode_SoundManager_Update(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SoundManager *inst = (SoundManager*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->Update();
+		return 0;
+	}
+	static int Polycode_SoundManager_setGlobalVolume(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SoundManager *inst = (SoundManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number globalVolume = lua_tonumber(L, 2);
+		inst->setGlobalVolume(globalVolume);
+		return 0;
+	}
+	static int Polycode_SoundManager_registerSound(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SoundManager *inst = (SoundManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Sound* sound = (Sound*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->registerSound(sound);
+		return 0;
+	}
+	static int Polycode_SoundManager_unregisterSound(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		SoundManager *inst = (SoundManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Sound* sound = (Sound*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->unregisterSound(sound);
+		return 0;
+	}
+	static int Polycode_String(lua_State *L) {
+		String *inst = new String();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.String");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_String_size(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		String *inst = (String*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->size());
+		return 1;
+	}
+	static int Polycode_String_length(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		String *inst = (String*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->length());
+		return 1;
+	}
+	static int Polycode_String_substr(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		String *inst = (String*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		size_t pos = *(size_t*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		size_t n = *(size_t*) *((PolyBase**)lua_touserdata(L, 3));
+		lua_pushstring(L, inst->substr(pos, n).c_str());
+		return 1;
+	}
+	static int Polycode_String_rfind(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		String *inst = (String*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String str = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		size_t pos = *(size_t*) *((PolyBase**)lua_touserdata(L, 3));
+		lua_pushinteger(L, inst->rfind(str, pos));
+		return 1;
+	}
+	static int Polycode_String_find(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		String *inst = (String*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String str = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		size_t pos = *(size_t*) *((PolyBase**)lua_touserdata(L, 3));
+		lua_pushinteger(L, inst->find(str, pos));
+		return 1;
+	}
+	static int Polycode_String_find_last_of(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		String *inst = (String*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String str = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		size_t pos = *(size_t*) *((PolyBase**)lua_touserdata(L, 3));
+		lua_pushinteger(L, inst->find_last_of(str, pos));
+		return 1;
+	}
+	static int Polycode_String_find_first_of(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		String *inst = (String*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String str = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TUSERDATA);
+		size_t pos = *(size_t*) *((PolyBase**)lua_touserdata(L, 3));
+		lua_pushinteger(L, inst->find_first_of(str, pos));
+		return 1;
+	}
+	static int Polycode_String_toLowerCase(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		String *inst = (String*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushstring(L, inst->toLowerCase().c_str());
+		return 1;
+	}
+	static int Polycode_String_toUpperCase(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		String *inst = (String*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushstring(L, inst->toUpperCase().c_str());
+		return 1;
+	}
+	static int Polycode_String_split(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		String *inst = (String*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String delim = String(lua_tostring(L, 2));
+	}
+	static int Polycode_String_replace(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		String *inst = (String*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TSTRING);
+		String what = String(lua_tostring(L, 2));
+		luaL_checktype(L, 3, LUA_TSTRING);
+		String withWhat = String(lua_tostring(L, 3));
+		lua_pushstring(L, inst->replace(what, withWhat).c_str());
+		return 1;
+	}
+	static int Polycode_String_NumberToString(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		String *inst = (String*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number value = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int precision = lua_tointeger(L, 3);
+		lua_pushstring(L, inst->NumberToString(value, precision).c_str());
+		return 1;
+	}
+	static int Polycode_String_toNumber(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		String *inst = (String*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->toNumber());
+		return 1;
+	}
+	static int Polycode_String_toInteger(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		String *inst = (String*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->toInteger());
+		return 1;
+	}
+	static int Polycode_String_IntToString(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		String *inst = (String*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int value = lua_tointeger(L, 2);
+		lua_pushstring(L, inst->IntToString(value).c_str());
+		return 1;
+	}
+	static int Polycode_String_c_str(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		String *inst = (String*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->c_str();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_String_getDataWithEncoding(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		String *inst = (String*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int encoding = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->getDataWithEncoding(encoding);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_String_getWDataWithEncoding(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		String *inst = (String*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int encoding = lua_tointeger(L, 2);
+		PolyBase *ptrRetVal = (PolyBase*)inst->getWDataWithEncoding(encoding);
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_String_append(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		String *inst = (String*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		char c = *(char*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->append(c);
+		return 0;
+	}
+	static int Polycode_String_getDataSizeWithEncoding(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		String *inst = (String*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int encoding = lua_tointeger(L, 2);
+		lua_pushinteger(L, inst->getDataSizeWithEncoding(encoding));
+		return 1;
+	}
+	static int Polycode_String_setDataWithEncoding(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		String *inst = (String*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		char* data = (char*) *((PolyBase**)lua_touserdata(L, 2));
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		int encoding = lua_tointeger(L, 3);
+		inst->setDataWithEncoding(data, encoding);
+		return 0;
+	}
+	static int Polycode_String_isNumber(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		String *inst = (String*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->isNumber());
+		return 1;
+	}
+	static int Polycode_RenderBuffer(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TNUMBER);
+		int width = lua_tointeger(L, 1);
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int height = lua_tointeger(L, 2);
+		luaL_checktype(L, 3, LUA_TBOOLEAN);
+		bool attachDepthBuffer = lua_toboolean(L, 3) != 0;
+		luaL_checktype(L, 4, LUA_TBOOLEAN);
+		bool floatingPoint = lua_toboolean(L, 4) != 0;
+		RenderBuffer *inst = new RenderBuffer(width, height, attachDepthBuffer, floatingPoint);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.RenderBuffer");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_RenderBuffer_getWidth(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		RenderBuffer *inst = (RenderBuffer*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getWidth());
+		return 1;
+	}
+	static int Polycode_RenderBuffer_getHeight(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		RenderBuffer *inst = (RenderBuffer*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getHeight());
+		return 1;
+	}
+	static int Polycode_Texture_reloadResource(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Texture *inst = (Texture*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->reloadResource();
+		return 0;
+	}
+	static int Polycode_Texture_setImageData(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Texture *inst = (Texture*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Image* data = (Image*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->setImageData(data);
+		return 0;
+	}
+	static int Polycode_Texture_getTextureData(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Texture *inst = (Texture*) *((PolyBase**)lua_touserdata(L, 1));
+		PolyBase *ptrRetVal = (PolyBase*)inst->getTextureData();
+		if(ptrRetVal == NULL) {
+			lua_pushnil(L);
+		} else {
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = ptrRetVal;
+		}
+		return 1;
+	}
+	static int Polycode_Texture_getWidth(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Texture *inst = (Texture*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getWidth());
+		return 1;
+	}
+	static int Polycode_Texture_getHeight(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Texture *inst = (Texture*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getHeight());
+		return 1;
+	}
+	static int Polycode_Texture_setCreateMipmaps(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Texture *inst = (Texture*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool createMipmapsIn = lua_toboolean(L, 2) != 0;
+		inst->setCreateMipmaps(createMipmapsIn);
+		return 0;
+	}
+	static int Polycode_Texture_getCreateMipmaps(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Texture *inst = (Texture*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->getCreateMipmaps());
+		return 1;
+	}
+	static int Polycode_Timer(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TBOOLEAN);
+		bool triggerMode = lua_toboolean(L, 1) != 0;
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int msecs = lua_tointeger(L, 2);
+		Timer *inst = new Timer(triggerMode, msecs);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.Timer");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Timer_Pause(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Timer *inst = (Timer*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TBOOLEAN);
+		bool paused = lua_toboolean(L, 2) != 0;
+		inst->Pause(paused);
+		return 0;
+	}
+	static int Polycode_Timer_isPaused(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Timer *inst = (Timer*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->isPaused());
+		return 1;
+	}
+	static int Polycode_Timer_getTicks(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Timer *inst = (Timer*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushinteger(L, inst->getTicks());
+		return 1;
+	}
+	static int Polycode_Timer_Update(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Timer *inst = (Timer*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int ticks = lua_tointeger(L, 2);
+		inst->Update(ticks);
+		return 0;
+	}
+	static int Polycode_Timer_Reset(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Timer *inst = (Timer*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->Reset();
+		return 0;
+	}
+	static int Polycode_Timer_hasElapsed(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Timer *inst = (Timer*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushboolean(L, inst->hasElapsed());
+		return 1;
+	}
+	static int Polycode_Timer_getElapsedf(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Timer *inst = (Timer*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->getElapsedf());
+		return 1;
+	}
+	static int Polycode_Timer_setTimerInterval(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Timer *inst = (Timer*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		int msecs = lua_tointeger(L, 2);
+		inst->setTimerInterval(msecs);
+		return 0;
+	}
+	static int Polycode_TimerManager(lua_State *L) {
+		TimerManager *inst = new TimerManager();
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.TimerManager");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_TimerManager_removeTimer(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		TimerManager *inst = (TimerManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Timer* timer = (Timer*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->removeTimer(timer);
+		return 0;
+	}
+	static int Polycode_TimerManager_addTimer(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		TimerManager *inst = (TimerManager*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Timer* timer = (Timer*) *((PolyBase**)lua_touserdata(L, 2));
+		inst->addTimer(timer);
+		return 0;
+	}
+	static int Polycode_TimerManager_Update(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		TimerManager *inst = (TimerManager*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->Update();
+		return 0;
+	}
+	static int Polycode_Vector2(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 1);
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 2);
+		Vector2 *inst = new Vector2(x, y);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.Vector2");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Vector2_set(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Vector2 *inst = (Vector2*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 3);
+		inst->set(x, y);
+		return 0;
+	}
+	static int Polycode_Vector2_distance(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Vector2 *inst = (Vector2*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector2 vec2 = *(Vector2*) *((PolyBase**)lua_touserdata(L, 2));
+		lua_pushnumber(L, inst->distance(vec2));
+		return 1;
+	}
+	static int Polycode_Vector2_length(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Vector2 *inst = (Vector2*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->length());
+		return 1;
+	}
+	static int Polycode_Vector2_dot(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Vector2 *inst = (Vector2*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector2 u = *(Vector2*) *((PolyBase**)lua_touserdata(L, 2));
+		lua_pushnumber(L, inst->dot(u));
+		return 1;
+	}
+	static int Polycode_Vector2_crossProduct(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Vector2 *inst = (Vector2*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector2 vec2 = *(Vector2*) *((PolyBase**)lua_touserdata(L, 2));
+		lua_pushnumber(L, inst->crossProduct(vec2));
+		return 1;
+	}
+	static int Polycode_Vector2_angle(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Vector2 *inst = (Vector2*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector2 vec2 = *(Vector2*) *((PolyBase**)lua_touserdata(L, 2));
+		lua_pushnumber(L, inst->angle(vec2));
+		return 1;
+	}
+	static int Polycode_Vector2_Normalize(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Vector2 *inst = (Vector2*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->Normalize();
+		return 0;
+	}
+	static int Polycode_Vector3(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 1);
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number z = lua_tonumber(L, 3);
+		Vector3 *inst = new Vector3(x, y, z);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Vector3_set(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Vector3 *inst = (Vector3*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number z = lua_tonumber(L, 4);
+		inst->set(x, y, z);
+		return 0;
+	}
+	static int Polycode_Vector3_distance(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Vector3 *inst = (Vector3*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 vec2 = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		lua_pushnumber(L, inst->distance(vec2));
+		return 1;
+	}
+	static int Polycode_Vector3_angleBetween(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Vector3 *inst = (Vector3*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 dest = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		lua_pushnumber(L, inst->angleBetween(dest));
+		return 1;
+	}
+	static int Polycode_Vector3_length(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Vector3 *inst = (Vector3*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->length());
+		return 1;
+	}
+	static int Polycode_Vector3_lengthSquared(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Vector3 *inst = (Vector3*) *((PolyBase**)lua_touserdata(L, 1));
+		lua_pushnumber(L, inst->lengthSquared());
+		return 1;
+	}
+	static int Polycode_Vector3_setLength(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Vector3 *inst = (Vector3*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number newLength = lua_tonumber(L, 2);
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->setLength(newLength);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Vector3_dot(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Vector3 *inst = (Vector3*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 u = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		lua_pushnumber(L, inst->dot(u));
+		return 1;
+	}
+	static int Polycode_Vector3_crossProduct(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Vector3 *inst = (Vector3*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector3 vec2 = *(Vector3*) *((PolyBase**)lua_touserdata(L, 2));
+		Vector3 *retInst = new Vector3();
+		*retInst = inst->crossProduct(vec2);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		luaL_getmetatable(L, "Polycode.Vector3");
+		lua_setmetatable(L, -2);
+		*userdataPtr = (PolyBase*)retInst;
+		return 1;
+	}
+	static int Polycode_Vector3_Normalize(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Vector3 *inst = (Vector3*) *((PolyBase**)lua_touserdata(L, 1));
+		inst->Normalize();
+		return 0;
+	}
+	static int Polycode_Vector4(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 1);
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number z = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number w = lua_tonumber(L, 4);
+		Vector4 *inst = new Vector4(x, y, z, w);
+		PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+		*userdataPtr = (PolyBase*)inst;
+		luaL_getmetatable(L, "Polycode.Vector4");
+		lua_setmetatable(L, -2);
+		return 1;
+	}
+	static int Polycode_Vector4_set(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Vector4 *inst = (Vector4*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TNUMBER);
+		Number x = lua_tonumber(L, 2);
+		luaL_checktype(L, 3, LUA_TNUMBER);
+		Number y = lua_tonumber(L, 3);
+		luaL_checktype(L, 4, LUA_TNUMBER);
+		Number z = lua_tonumber(L, 4);
+		luaL_checktype(L, 5, LUA_TNUMBER);
+		Number w = lua_tonumber(L, 5);
+		inst->set(x, y, z, w);
+		return 0;
+	}
+	static int Polycode_Vector4_dot(lua_State *L) {
+		luaL_checktype(L, 1, LUA_TUSERDATA);
+		Vector4 *inst = (Vector4*) *((PolyBase**)lua_touserdata(L, 1));
+		luaL_checktype(L, 2, LUA_TUSERDATA);
+		Vector4 u = *(Vector4*) *((PolyBase**)lua_touserdata(L, 2));
+		lua_pushnumber(L, inst->dot(u));
+		return 1;
+	}
+
+
+}

scripts/create_lua_library/bindings.conf

@@ -0,0 +1,27 @@
+#Bindings generator config
+
+# global bindings settings
+[global]
+#target directory containing header files to parse
+TargetDirectory = ../../include/polycode/core
+#include path prefix used when including the header files from generated headers (i.e. bar for #include "bar/Foo.h")
+HeaderIncludeDirectory = polycode/core
+#comma separated list of header files without extensions to ignore (i.e. Foo for Foo.h)
+IgnoreFiles = PolyTween, PolyTweenManager, PolyGLSLProgram, PolyGLSLShader, PolyGLSLShaderModule, PolyWinCore, PolyIOSCore, PolyRPICore, PolyUWPCore, PolyCocoaCore, PolyAGLCore, PolySDLCore, Poly_iPhone, PolyGLES1Renderer, PolyGLRenderer, tinyxml, tinystr, OpenGLCubemap, PolyiPhoneCore, PolyGLES1Texture, PolyGLTexture, PolyGLVertexBuffer, PolyThreaded, PolyGLHeaders, GLee, PolyPeer, PolySocket, PolyClient, PolyServer, PolyServerWorld, OSFILE, OSFileEntry, OSBasics, PolyLogger, PolyFontGlyphSheet, PolyXAudio2AudioInterface
+#comma separated list of non-standard symbols to strip that might affect header parsing (i.e. __declspec(dllexport))
+StripSymbols = _PolyExport
+#comma separated list of classes to ignore when parsing (i.e. CFoo, CBar)
+IgnoreClasses = PAAudioInterface, AudioInterface, ResourceLoader, CoreFile, CoreFileProvider, GraphicsInterface, Script, LuaScript, JSScript, Object, Threaded, OpenGLCubemap, PolyBase, Matrix4::union
+#comma separated list of class methods to ignore
+IgnoreMethods = readByte32, readByte16, getCustomEntitiesByType, Core, Renderer, Shader, Texture, handleEvent, secondaryHandler, getSTLString, readInt, CoreServices
+LibraryName = Polycode
+
+#settings for the lua bindings generator
+[lua]
+#comma separated list of classes that will not be garbage collected by Lua (Foo, Bar)
+DisableGarbageCollection = Entity,SceneLabel, SceneMesh, Scene, Texture, Image, Camera, SceneParticleEmitter, Mesh, Vertex, Polygon, Polycode::Polygon, Material, ScenePrimitive, SceneLine, SceneLight, SceneSound, SceneImage, SceneEntity, SceneEntityInstance, SceneSprite
+#template file for the lua wrappers header file
+WrapperHeaderTemplate = templates/lua_wrappers.h
+#target header file the wrappers will be written to
+WrapperHeaderTarget = PolycodeLuaWrappers.h
+

scripts/create_lua_library/create_bindings.py

@@ -0,0 +1,5 @@
+from BindingsGenerator import *
+
+engines = {}
+generator = BindingsGenerator(engines, "bindings.conf")
+generator.createBindings()

scripts/create_lua_library/templates/lua_wrappers.h

@@ -0,0 +1,34 @@
+#pragma once
+
+extern "C" {
+	#include <stdio.h>
+	#include "lua.h"
+	#include "lualib.h"
+	#include "lauxlib.h"
+} 
+
+%HEADERS%
+
+using namespace std;
+namespace Polycode {
+
+	class LuaEventHandler : public EventHandler {
+	public:
+		LuaEventHandler() : EventHandler() {}
+		void handleEvent(Event *e) {
+			lua_getglobal(L, "__customError");
+			int errH = lua_gettop(L);
+			lua_getglobal(L, "__handleEvent");
+			lua_rawgeti( L, LUA_REGISTRYINDEX, wrapperIndex );
+			PolyBase **userdataPtr = (PolyBase**)lua_newuserdata(L, sizeof(PolyBase*));
+			*userdataPtr = (PolyBase*)e;
+			lua_pcall(L, 2, 0, errH);
+			lua_settop(L, 0);
+		}
+		int wrapperIndex;
+		lua_State *L;
+	};
+
+%BODY%
+
+}