First pass at automatic JavaScript bindings generation (no returns, instantiations, GC yet), added ability to include JS scripts from file sources, fixed crash on JavaScript error

bindings/javascript/Polycode.js

@@ -0,0 +1,121 @@
+require('Polycode/BezierCurve')
+require('Polycode/BezierPoint')
+require('Polycode/Bone')
+require('Polycode/Camera')
+require('Polycode/Color')
+require('Polycode/ConfigEntry')
+require('Polycode/Config')
+require('Polycode/Core')
+require('Polycode/VideoModeChangeInfo')
+require('Polycode/PolycodeViewBase')
+require('Polycode/DummyCore')
+require('Polycode/TimeInfo')
+require('Polycode/CoreMutex')
+require('Polycode/CoreMotionEvent')
+require('Polycode/CoreFileExtension')
+require('Polycode/OSFileEntry')
+require('Polycode/CoreInput')
+require('Polycode/JoystickInfo')
+require('Polycode/CoreServices')
+require('Polycode/Data')
+require('Polycode/MouseEventResult')
+require('Polycode/EntityProp')
+require('Polycode/AABB')
+require('Polycode/Rotation')
+require('Polycode/Entity')
+require('Polycode/Event')
+require('Polycode/EventDispatcher')
+require('Polycode/EventHandler')
+require('Polycode/Font')
+require('Polycode/LightInfo')
+require('Polycode/GPUDrawCall')
+require('Polycode/GPUDrawOptions')
+require('Polycode/GPUDrawBuffer')
+require('Polycode/Image')
+require('Polycode/TouchInfo')
+require('Polycode/InputEvent')
+require('Polycode/GlyphData')
+require('Polycode/ColorRange')
+require('Polycode/Label')
+require('Polycode/Material')
+require('Polycode/ShaderPass')
+require('Polycode/MaterialManager')
+require('Polycode/Matrix4')
+require('Polycode/Mesh')
+require('Polycode/ObjectEntry')
+require('Polycode/BinaryObjectReader')
+require('Polycode/BinaryObjectWriter')
+require('Polycode/SceneParticle')
+require('Polycode/SceneParticleEmitter')
+require('Polycode/Perlin')
+require('Polycode/Quaternion')
+require('Polycode/QuatTriple')
+require('Polycode/QuaternionCurve')
+require('Polycode/Ray')
+require('Polycode/Rectangle')
+require('Polycode/RenderDataArray')
+require('Polycode/VertexDataArray')
+require('Polycode/IndexDataArray')
+require('Polycode/LightShadowInfoBinding')
+require('Polycode/LightInfoBinding')
+require('Polycode/RenderFrame')
+require('Polycode/RendererThreadJob')
+require('Polycode/RenderThread')
+require('Polycode/RenderThreadDebugInfo')
+require('Polycode/Renderer')
+require('Polycode/Resource')
+require('Polycode/ScriptResourceLoader')
+require('Polycode/ResourcePool')
+require('Polycode/ResourceManager')
+require('Polycode/FontResourceLoader')
+require('Polycode/ProgramResourceLoader')
+require('Polycode/DebugBackTraceEntry')
+require('Polycode/MeshResourceLoader')
+require('Polycode/MaterialResourceLoader')
+require('Polycode/TextureResourceLoader')
+require('Polycode/Scene')
+require('Polycode/SceneEntityInstanceResourceEntry')
+require('Polycode/SceneEntityInstance')
+require('Polycode/SceneEntityInstanceLayer')
+require('Polycode/SceneImage')
+require('Polycode/SceneLabel')
+require('Polycode/SceneLight')
+require('Polycode/SceneCurve')
+require('Polycode/SceneLine')
+require('Polycode/SceneManager')
+require('Polycode/SceneMesh')
+require('Polycode/ScenePrimitive')
+require('Polycode/SceneRenderTexture')
+require('Polycode/SceneSound')
+require('Polycode/SceneSoundListener')
+require('Polycode/SceneSprite')
+require('Polycode/Sprite')
+require('Polycode/SpriteSet')
+require('Polycode/SpriteFrame')
+require('Polycode/SpriteState')
+require('Polycode/JSScriptInstance')
+require('Polycode/LuaScriptInstance')
+require('Polycode/ScriptInstance')
+require('Polycode/ProgramParam')
+require('Polycode/ProgramAttribute')
+require('Polycode/ShaderRenderTarget')
+require('Polycode/RenderTargetBinding')
+require('Polycode/Shader')
+require('Polycode/LocalShaderParam')
+require('Polycode/ShaderProgram')
+require('Polycode/AttributeBinding')
+require('Polycode/ShaderBinding')
+require('Polycode/SkeletonAnimation')
+require('Polycode/Skeleton')
+require('Polycode/BoneTrack')
+require('Polycode/Sound')
+require('Polycode/AudioStreamingSource')
+require('Polycode/AudioMixer')
+require('Polycode/SoundManager')
+require('Polycode/String')
+require('Polycode/RenderBuffer')
+require('Polycode/Texture')
+require('Polycode/Timer')
+require('Polycode/Vector2')
+require('Polycode/Vector3')
+require('Polycode/Vector4')

bindings/javascript/Polycode/AABB.js

@@ -0,0 +1,2 @@
+function AABB() {
+}

bindings/javascript/Polycode/AttributeBinding.js

@@ -0,0 +1,2 @@
+function AttributeBinding() {
+}

bindings/javascript/Polycode/AudioMixer.js

@@ -0,0 +1,6 @@
+function AudioMixer() {
+}
+
+AudioMixer.prototype.mixIntoBuffer = function(buffer,numSamples) {
+	Polycode.AudioMixer_mixIntoBuffer(this.__ptr, buffer,numSamples)
+}

bindings/javascript/Polycode/AudioStreamingSource.js

@@ -0,0 +1,10 @@
+function AudioStreamingSource() {
+}
+
+AudioStreamingSource.prototype.getNumChannels = function() {
+	Polycode.AudioStreamingSource_getNumChannels(this.__ptr)
+}
+
+AudioStreamingSource.prototype.getFrequency = function() {
+	Polycode.AudioStreamingSource_getFrequency(this.__ptr)
+}

bindings/javascript/Polycode/BasicFile.js

@@ -0,0 +1,18 @@
+function BasicFile() {
+}
+
+BasicFile.prototype.read = function(ptr,size,count) {
+	Polycode.BasicFile_read(this.__ptr, ptr,size,count)
+}
+
+BasicFile.prototype.write = function(ptr,size,count) {
+	Polycode.BasicFile_write(this.__ptr, ptr,size,count)
+}
+
+BasicFile.prototype.seek = function(offset,origin) {
+	Polycode.BasicFile_seek(this.__ptr, offset,origin)
+}
+
+BasicFile.prototype.tell = function() {
+	Polycode.BasicFile_tell(this.__ptr)
+}

bindings/javascript/Polycode/BasicFileProvider.js

@@ -0,0 +1,18 @@
+function BasicFileProvider() {
+}
+
+BasicFileProvider.prototype.openFile = function(fileName,opts) {
+	Polycode.BasicFileProvider_openFile(this.__ptr, fileName,opts)
+}
+
+BasicFileProvider.prototype.closeFile = function(file) {
+	Polycode.BasicFileProvider_closeFile(this.__ptr, file)
+}
+
+BasicFileProvider.prototype.addSource = function(source) {
+	Polycode.BasicFileProvider_addSource(this.__ptr, source)
+}
+
+BasicFileProvider.prototype.removeSource = function(source) {
+	Polycode.BasicFileProvider_removeSource(this.__ptr, source)
+}

bindings/javascript/Polycode/BezierCurve.js

@@ -0,0 +1,66 @@
+function BezierCurve() {
+}
+
+BezierCurve.prototype.getControlPoint = function(index) {
+	Polycode.BezierCurve_getControlPoint(this.__ptr, index)
+}
+
+BezierCurve.prototype.getNumControlPoints = function() {
+	Polycode.BezierCurve_getNumControlPoints(this.__ptr)
+}
+
+BezierCurve.prototype.addControlPoint = function(p1x,p1y,p1z,p2x,p2y,p2z,p3x,p3y,p3z) {
+	Polycode.BezierCurve_addControlPoint(this.__ptr, p1x,p1y,p1z,p2x,p2y,p2z,p3x,p3y,p3z)
+}
+
+BezierCurve.prototype.addControlPoint3dWithHandles = function(p1x,p1y,p1z,p2x,p2y,p2z,p3x,p3y,p3z) {
+	Polycode.BezierCurve_addControlPoint3dWithHandles(this.__ptr, p1x,p1y,p1z,p2x,p2y,p2z,p3x,p3y,p3z)
+}
+
+BezierCurve.prototype.addControlPoint3d = function(x,y,z) {
+	Polycode.BezierCurve_addControlPoint3d(this.__ptr, x,y,z)
+}
+
+BezierCurve.prototype.addControlPoint2dWithHandles = function(p1x,p1y,p2x,p2y,p3x,p3y) {
+	Polycode.BezierCurve_addControlPoint2dWithHandles(this.__ptr, p1x,p1y,p2x,p2y,p3x,p3y)
+}
+
+BezierCurve.prototype.addControlPoint2d = function(x,y) {
+	Polycode.BezierCurve_addControlPoint2d(this.__ptr, x,y)
+}
+
+BezierCurve.prototype.getPointAt = function(a) {
+	Polycode.BezierCurve_getPointAt(this.__ptr, a)
+}
+
+BezierCurve.prototype.getPointBetween = function(a,bp1,bp2) {
+	Polycode.BezierCurve_getPointBetween(this.__ptr, a,bp1,bp2)
+}
+
+BezierCurve.prototype.clearControlPoints = function() {
+	Polycode.BezierCurve_clearControlPoints(this.__ptr)
+}
+
+BezierCurve.prototype.getYValueAtX = function(x) {
+	Polycode.BezierCurve_getYValueAtX(this.__ptr, x)
+}
+
+BezierCurve.prototype.getTValueAtX = function(x) {
+	Polycode.BezierCurve_getTValueAtX(this.__ptr, x)
+}
+
+BezierCurve.prototype.removePoint = function(point) {
+	Polycode.BezierCurve_removePoint(this.__ptr, point)
+}
+
+BezierCurve.prototype.setHeightCacheResolution = function(resolution) {
+	Polycode.BezierCurve_setHeightCacheResolution(this.__ptr, resolution)
+}
+
+BezierCurve.prototype.rebuildHeightCache = function() {
+	Polycode.BezierCurve_rebuildHeightCache(this.__ptr)
+}
+
+BezierCurve.prototype.recalculateDistances = function() {
+	Polycode.BezierCurve_recalculateDistances(this.__ptr)
+}

bindings/javascript/Polycode/BezierPoint.js

@@ -0,0 +1,2 @@
+function BezierPoint() {
+}

bindings/javascript/Polycode/BinaryObjectReader.js

@@ -0,0 +1,2 @@
+function BinaryObjectReader() {
+}

bindings/javascript/Polycode/BinaryObjectWriter.js

@@ -0,0 +1,22 @@
+function BinaryObjectWriter() {
+}
+
+BinaryObjectWriter.prototype.parseKeysFromObjectEntry = function(entry) {
+	Polycode.BinaryObjectWriter_parseKeysFromObjectEntry(this.__ptr, entry)
+}
+
+BinaryObjectWriter.prototype.writeEntryToFile = function(entry) {
+	Polycode.BinaryObjectWriter_writeEntryToFile(this.__ptr, entry)
+}
+
+BinaryObjectWriter.prototype.addKey = function(key) {
+	Polycode.BinaryObjectWriter_addKey(this.__ptr, key)
+}
+
+BinaryObjectWriter.prototype.getKeyIndex = function(key) {
+	Polycode.BinaryObjectWriter_getKeyIndex(this.__ptr, key)
+}
+
+BinaryObjectWriter.prototype.writeToFile = function(fileName) {
+	Polycode.BinaryObjectWriter_writeToFile(this.__ptr, fileName)
+}

bindings/javascript/Polycode/Bone.js

@@ -0,0 +1,78 @@
+function Bone() {
+}
+
+Bone.prototype.getName = function() {
+	Polycode.Bone_getName(this.__ptr)
+}
+
+Bone.prototype.setParentBone = function(bone) {
+	Polycode.Bone_setParentBone(this.__ptr, bone)
+}
+
+Bone.prototype.addChildBone = function(bone) {
+	Polycode.Bone_addChildBone(this.__ptr, bone)
+}
+
+Bone.prototype.getParentBone = function() {
+	Polycode.Bone_getParentBone(this.__ptr)
+}
+
+Bone.prototype.getNumChildBones = function() {
+	Polycode.Bone_getNumChildBones(this.__ptr)
+}
+
+Bone.prototype.getChildBone = function(index) {
+	Polycode.Bone_getChildBone(this.__ptr, index)
+}
+
+Bone.prototype.getBoneMatrix = function() {
+	Polycode.Bone_getBoneMatrix(this.__ptr)
+}
+
+Bone.prototype.setBoneMatrix = function(matrix) {
+	Polycode.Bone_setBoneMatrix(this.__ptr, matrix)
+}
+
+Bone.prototype.getRestMatrix = function() {
+	Polycode.Bone_getRestMatrix(this.__ptr)
+}
+
+Bone.prototype.getFullRestMatrix = function() {
+	Polycode.Bone_getFullRestMatrix(this.__ptr)
+}
+
+Bone.prototype.getParentRestMatrix = function() {
+	Polycode.Bone_getParentRestMatrix(this.__ptr)
+}
+
+Bone.prototype.getFinalMatrix = function() {
+	Polycode.Bone_getFinalMatrix(this.__ptr)
+}
+
+Bone.prototype.setRestMatrix = function(matrix) {
+	Polycode.Bone_setRestMatrix(this.__ptr, matrix)
+}
+
+Bone.prototype.setBaseMatrix = function(matrix) {
+	Polycode.Bone_setBaseMatrix(this.__ptr, matrix)
+}
+
+Bone.prototype.getBaseMatrix = function() {
+	Polycode.Bone_getBaseMatrix(this.__ptr)
+}
+
+Bone.prototype.getFullBaseMatrix = function() {
+	Polycode.Bone_getFullBaseMatrix(this.__ptr)
+}
+
+Bone.prototype.rebuildFinalMatrix = function() {
+	Polycode.Bone_rebuildFinalMatrix(this.__ptr)
+}
+
+Bone.prototype.buildFinalMatrix = function() {
+	Polycode.Bone_buildFinalMatrix(this.__ptr)
+}
+
+Bone.prototype.intializeBone = function(basePosition,baseScale,baseRotation,restPosition,restScale,restRotation) {
+	Polycode.Bone_intializeBone(this.__ptr, basePosition,baseScale,baseRotation,restPosition,restScale,restRotation)
+}

bindings/javascript/Polycode/BoneTrack.js

@@ -0,0 +1,22 @@
+function BoneTrack() {
+}
+
+BoneTrack.prototype.Play = function(once) {
+	Polycode.BoneTrack_Play(this.__ptr, once)
+}
+
+BoneTrack.prototype.Stop = function() {
+	Polycode.BoneTrack_Stop(this.__ptr)
+}
+
+BoneTrack.prototype.Update = function(elapsed) {
+	Polycode.BoneTrack_Update(this.__ptr, elapsed)
+}
+
+BoneTrack.prototype.Reset = function() {
+	Polycode.BoneTrack_Reset(this.__ptr)
+}
+
+BoneTrack.prototype.setSpeed = function(speed) {
+	Polycode.BoneTrack_setSpeed(this.__ptr, speed)
+}

bindings/javascript/Polycode/Camera.js

@@ -0,0 +1,150 @@
+function Camera() {
+}
+
+Camera.prototype.buildFrustumPlanes = function() {
+	Polycode.Camera_buildFrustumPlanes(this.__ptr)
+}
+
+Camera.prototype.isSphereInFrustum = function(pos,fRadius) {
+	Polycode.Camera_isSphereInFrustum(this.__ptr, pos,fRadius)
+}
+
+Camera.prototype.isAABBInFrustum = function(aabb) {
+	Polycode.Camera_isAABBInFrustum(this.__ptr, aabb)
+}
+
+Camera.prototype.setOrthoMode = function(mode) {
+	Polycode.Camera_setOrthoMode(this.__ptr, mode)
+}
+
+Camera.prototype.setOrthoSize = function(orthoSizeX,orthoSizeY) {
+	Polycode.Camera_setOrthoSize(this.__ptr, orthoSizeX,orthoSizeY)
+}
+
+Camera.prototype.setFrustumMode = function(left,right,bottom,top,front,back) {
+	Polycode.Camera_setFrustumMode(this.__ptr, left,right,bottom,top,front,back)
+}
+
+Camera.prototype.getOrthoMode = function() {
+	Polycode.Camera_getOrthoMode(this.__ptr)
+}
+
+Camera.prototype.getOrthoSizeX = function() {
+	Polycode.Camera_getOrthoSizeX(this.__ptr)
+}
+
+Camera.prototype.getOrthoSizeY = function() {
+	Polycode.Camera_getOrthoSizeY(this.__ptr)
+}
+
+Camera.prototype.setFOV = function(fov) {
+	Polycode.Camera_setFOV(this.__ptr, fov)
+}
+
+Camera.prototype.getFOV = function() {
+	Polycode.Camera_getFOV(this.__ptr)
+}
+
+Camera.prototype.setClippingPlanes = function(nearClipPlane,farClipPlane) {
+	Polycode.Camera_setClippingPlanes(this.__ptr, nearClipPlane,farClipPlane)
+}
+
+Camera.prototype.getNearClippingPlane = function() {
+	Polycode.Camera_getNearClippingPlane(this.__ptr)
+}
+
+Camera.prototype.getFarClippingPlane = function() {
+	Polycode.Camera_getFarClippingPlane(this.__ptr)
+}
+
+Camera.prototype.setParentScene = function(parentScene) {
+	Polycode.Camera_setParentScene(this.__ptr, parentScene)
+}
+
+Camera.prototype.getParentScene = function() {
+	Polycode.Camera_getParentScene(this.__ptr)
+}
+
+Camera.prototype.createProjectionMatrix = function() {
+	Polycode.Camera_createProjectionMatrix(this.__ptr)
+}
+
+Camera.prototype.hasFilterShader = function() {
+	Polycode.Camera_hasFilterShader(this.__ptr)
+}
+
+Camera.prototype.drawFilter = function(targetBuffer) {
+	Polycode.Camera_drawFilter(this.__ptr, targetBuffer)
+}
+
+Camera.prototype.setPostFilter = function(material) {
+	Polycode.Camera_setPostFilter(this.__ptr, material)
+}
+
+Camera.prototype.setPostFilterByName = function(shaderName) {
+	Polycode.Camera_setPostFilterByName(this.__ptr, shaderName)
+}
+
+Camera.prototype.removePostFilter = function() {
+	Polycode.Camera_removePostFilter(this.__ptr)
+}
+
+Camera.prototype.getScreenShaderMaterial = function() {
+	Polycode.Camera_getScreenShaderMaterial(this.__ptr)
+}
+
+Camera.prototype.Clone = function(deepClone,ignoreEditorOnly) {
+	Polycode.Camera_Clone(this.__ptr, deepClone,ignoreEditorOnly)
+}
+
+Camera.prototype.applyClone = function(clone,deepClone,ignoreEditorOnly) {
+	Polycode.Camera_applyClone(this.__ptr, clone,deepClone,ignoreEditorOnly)
+}
+
+Camera.prototype.getProjectionMatrix = function() {
+	Polycode.Camera_getProjectionMatrix(this.__ptr)
+}
+
+Camera.prototype.setCustomProjectionMatrix = function(matrix) {
+	Polycode.Camera_setCustomProjectionMatrix(this.__ptr, matrix)
+}
+
+Camera.prototype.getViewport = function() {
+	Polycode.Camera_getViewport(this.__ptr)
+}
+
+Camera.prototype.setViewport = function(viewport) {
+	Polycode.Camera_setViewport(this.__ptr, viewport)
+}
+
+Camera.prototype.setOrthoSizeMode = function(orthoSizeMode) {
+	Polycode.Camera_setOrthoSizeMode(this.__ptr, orthoSizeMode)
+}
+
+Camera.prototype.getOrthoSizeMode = function() {
+	Polycode.Camera_getOrthoSizeMode(this.__ptr)
+}
+
+Camera.prototype.setProjectionMode = function(mode) {
+	Polycode.Camera_setProjectionMode(this.__ptr, mode)
+}
+
+Camera.prototype.getProjectionMode = function() {
+	Polycode.Camera_getProjectionMode(this.__ptr)
+}
+
+Camera.prototype.projectRayFrom2DCoordinate = function(coordinate,viewport) {
+	Polycode.Camera_projectRayFrom2DCoordinate(this.__ptr, coordinate,viewport)
+}
+
+Camera.prototype.renderFullScreenQuad = function(drawBuffer,shaderPass) {
+	Polycode.Camera_renderFullScreenQuad(this.__ptr, drawBuffer,shaderPass)
+}
+
+Camera.prototype.getShaderPass = function(index) {
+	Polycode.Camera_getShaderPass(this.__ptr, index)
+}
+
+Camera.prototype.getNumShaderPasses = function() {
+	Polycode.Camera_getNumShaderPasses(this.__ptr)
+}

bindings/javascript/Polycode/Color.js

@@ -0,0 +1,62 @@
+function Color() {
+}
+
+Color.prototype.setColorHex = function(hex) {
+	Polycode.Color_setColorHex(this.__ptr, hex)
+}
+
+Color.prototype.setColorHexRGB = function(hex) {
+	Polycode.Color_setColorHexRGB(this.__ptr, hex)
+}
+
+Color.prototype.setColorHexFromString = function(hex) {
+	Polycode.Color_setColorHexFromString(this.__ptr, hex)
+}
+
+Color.prototype.setColorHexRGBFromString = function(hex) {
+	Polycode.Color_setColorHexRGBFromString(this.__ptr, hex)
+}
+
+Color.prototype.setColorHSV = function(h,s,v) {
+	Polycode.Color_setColorHSV(this.__ptr, h,s,v)
+}
+
+Color.prototype.setColorRGBA = function(r,g,b,a) {
+	Polycode.Color_setColorRGBA(this.__ptr, r,g,b,a)
+}
+
+Color.prototype.setColorRGB = function(r,g,b) {
+	Polycode.Color_setColorRGB(this.__ptr, r,g,b)
+}
+
+Color.prototype.setColor = function(r,g,b,a) {
+	Polycode.Color_setColor(this.__ptr, r,g,b,a)
+}
+
+Color.prototype.blendColor = function(c2,mode,amount,c3) {
+	Polycode.Color_blendColor(this.__ptr, c2,mode,amount,c3)
+}
+
+Color.prototype.Random = function() {
+	Polycode.Color_Random(this.__ptr)
+}
+
+Color.prototype.getBrightness = function() {
+	Polycode.Color_getBrightness(this.__ptr)
+}
+
+Color.prototype.getHue = function() {
+	Polycode.Color_getHue(this.__ptr)
+}
+
+Color.prototype.getSaturation = function() {
+	Polycode.Color_getSaturation(this.__ptr)
+}
+
+Color.prototype.getValue = function() {
+	Polycode.Color_getValue(this.__ptr)
+}
+
+Color.prototype.getUint = function() {
+	Polycode.Color_getUint(this.__ptr)
+}

bindings/javascript/Polycode/ColorRange.js

@@ -0,0 +1,2 @@
+function ColorRange() {
+}

bindings/javascript/Polycode/Config.js

@@ -0,0 +1,38 @@
+function Config() {
+}
+
+Config.prototype.loadConfig = function(configNamespace,fileName) {
+	Polycode.Config_loadConfig(this.__ptr, configNamespace,fileName)
+}
+
+Config.prototype.saveConfig = function(configNamespace,fileName) {
+	Polycode.Config_saveConfig(this.__ptr, configNamespace,fileName)
+}
+
+Config.prototype.getEntry = function(configNamespace,key) {
+	Polycode.Config_getEntry(this.__ptr, configNamespace,key)
+}
+
+Config.prototype.setStringValue = function(configNamespace,key,value) {
+	Polycode.Config_setStringValue(this.__ptr, configNamespace,key,value)
+}
+
+Config.prototype.setNumericValue = function(configNamespace,key,value) {
+	Polycode.Config_setNumericValue(this.__ptr, configNamespace,key,value)
+}
+
+Config.prototype.getNumericValue = function(configNamespace,key) {
+	Polycode.Config_getNumericValue(this.__ptr, configNamespace,key)
+}
+
+Config.prototype.getStringValue = function(configNamespace,key) {
+	Polycode.Config_getStringValue(this.__ptr, configNamespace,key)
+}
+
+Config.prototype.setBoolValue = function(configNamespace,key,value) {
+	Polycode.Config_setBoolValue(this.__ptr, configNamespace,key,value)
+}
+
+Config.prototype.getBoolValue = function(configNamespace,key) {
+	Polycode.Config_getBoolValue(this.__ptr, configNamespace,key)
+}

bindings/javascript/Polycode/ConfigEntry.js

@@ -0,0 +1,2 @@
+function ConfigEntry() {
+}

bindings/javascript/Polycode/Core.js

@@ -0,0 +1,254 @@
+function Core() {
+}
+
+Core.prototype.Update = function() {
+	Polycode.Core_Update(this.__ptr)
+}
+
+Core.prototype.Render = function() {
+	Polycode.Core_Render(this.__ptr)
+}
+
+Core.prototype.fixedUpdate = function() {
+	Polycode.Core_fixedUpdate(this.__ptr)
+}
+
+Core.prototype.systemUpdate = function() {
+	Polycode.Core_systemUpdate(this.__ptr)
+}
+
+Core.prototype.updateAndRender = function() {
+	Polycode.Core_updateAndRender(this.__ptr)
+}
+
+Core.prototype.enableMouse = function(newval) {
+	Polycode.Core_enableMouse(this.__ptr, newval)
+}
+
+Core.prototype.captureMouse = function(newval) {
+	Polycode.Core_captureMouse(this.__ptr, newval)
+}
+
+Core.prototype.setCursor = function(cursorType) {
+	Polycode.Core_setCursor(this.__ptr, cursorType)
+}
+
+Core.prototype.warpCursor = function(x,y) {
+	Polycode.Core_warpCursor(this.__ptr, x,y)
+}
+
+Core.prototype.createThread = function(target) {
+	Polycode.Core_createThread(this.__ptr, target)
+}
+
+Core.prototype.lockMutex = function(mutex) {
+	Polycode.Core_lockMutex(this.__ptr, mutex)
+}
+
+Core.prototype.unlockMutex = function(mutex) {
+	Polycode.Core_unlockMutex(this.__ptr, mutex)
+}
+
+Core.prototype.createMutex = function() {
+	Polycode.Core_createMutex(this.__ptr)
+}
+
+Core.prototype.copyStringToClipboard = function(str) {
+	Polycode.Core_copyStringToClipboard(this.__ptr, str)
+}
+
+Core.prototype.getClipboardString = function() {
+	Polycode.Core_getClipboardString(this.__ptr)
+}
+
+Core.prototype.getServices = function() {
+	Polycode.Core_getServices(this.__ptr)
+}
+
+Core.prototype.getFPS = function() {
+	Polycode.Core_getFPS(this.__ptr)
+}
+
+Core.prototype.Shutdown = function() {
+	Polycode.Core_Shutdown(this.__ptr)
+}
+
+Core.prototype.isFullscreen = function() {
+	Polycode.Core_isFullscreen(this.__ptr)
+}
+
+Core.prototype.getAALevel = function() {
+	Polycode.Core_getAALevel(this.__ptr)
+}
+
+Core.prototype.getInput = function() {
+	Polycode.Core_getInput(this.__ptr)
+}
+
+Core.prototype.getXRes = function() {
+	Polycode.Core_getXRes(this.__ptr)
+}
+
+Core.prototype.getYRes = function() {
+	Polycode.Core_getYRes(this.__ptr)
+}
+
+Core.prototype.getBackingXRes = function() {
+	Polycode.Core_getBackingXRes(this.__ptr)
+}
+
+Core.prototype.getBackingYRes = function() {
+	Polycode.Core_getBackingYRes(this.__ptr)
+}
+
+Core.prototype.getScreenWidth = function() {
+	Polycode.Core_getScreenWidth(this.__ptr)
+}
+
+Core.prototype.getScreenHeight = function() {
+	Polycode.Core_getScreenHeight(this.__ptr)
+}
+
+Core.prototype.createFolder = function(folderPath) {
+	Polycode.Core_createFolder(this.__ptr, folderPath)
+}
+
+Core.prototype.copyDiskItem = function(itemPath,destItemPath) {
+	Polycode.Core_copyDiskItem(this.__ptr, itemPath,destItemPath)
+}
+
+Core.prototype.moveDiskItem = function(itemPath,destItemPath) {
+	Polycode.Core_moveDiskItem(this.__ptr, itemPath,destItemPath)
+}
+
+Core.prototype.removeDiskItem = function(itemPath) {
+	Polycode.Core_removeDiskItem(this.__ptr, itemPath)
+}
+
+Core.prototype.openFolderPicker = function() {
+	Polycode.Core_openFolderPicker(this.__ptr)
+}
+
+Core.prototype.setFramerate = function(frameRate,maxFixedCycles) {
+	Polycode.Core_setFramerate(this.__ptr, frameRate,maxFixedCycles)
+}
+
+Core.prototype.openFilePicker = function(extensions,allowMultiple) {
+	Polycode.Core_openFilePicker(this.__ptr, extensions,allowMultiple)
+}
+
+Core.prototype.saveFilePicker = function(extensions) {
+	Polycode.Core_saveFilePicker(this.__ptr, extensions)
+}
+
+Core.prototype.handleVideoModeChange = function(modeInfo) {
+	Polycode.Core_handleVideoModeChange(this.__ptr, modeInfo)
+}
+
+Core.prototype.flushRenderContext = function() {
+	Polycode.Core_flushRenderContext(this.__ptr)
+}
+
+Core.prototype.prepareRenderContext = function() {
+	Polycode.Core_prepareRenderContext(this.__ptr)
+}
+
+Core.prototype.openFile = function(fileName,opts) {
+	Polycode.Core_openFile(this.__ptr, fileName,opts)
+}
+
+Core.prototype.closeFile = function(file) {
+	Polycode.Core_closeFile(this.__ptr, file)
+}
+
+Core.prototype.addFileSource = function(type,source) {
+	Polycode.Core_addFileSource(this.__ptr, type,source)
+}
+
+Core.prototype.removeFileSource = function(type,source) {
+	Polycode.Core_removeFileSource(this.__ptr, type,source)
+}
+
+Core.prototype.parseFolder = function(pathString,showHidden) {
+	Polycode.Core_parseFolder(this.__ptr, pathString,showHidden)
+}
+
+Core.prototype.systemParseFolder = function(pathString,showHidden,targetVector) {
+	Polycode.Core_systemParseFolder(this.__ptr, pathString,showHidden,targetVector)
+}
+
+Core.prototype.getResourcePathForFile = function(fileName) {
+	Polycode.Core_getResourcePathForFile(this.__ptr, fileName)
+}
+
+Core.prototype.setVideoMode = function(xRes,yRes,fullScreen,vSync,aaLevel,anisotropyLevel,retinaSupport) {
+	Polycode.Core_setVideoMode(this.__ptr, xRes,yRes,fullScreen,vSync,aaLevel,anisotropyLevel,retinaSupport)
+}
+
+Core.prototype.resizeTo = function(xRes,yRes) {
+	Polycode.Core_resizeTo(this.__ptr, xRes,yRes)
+}
+
+Core.prototype.doSleep = function() {
+	Polycode.Core_doSleep(this.__ptr)
+}
+
+Core.prototype.openURL = function(url) {
+	Polycode.Core_openURL(this.__ptr, url)
+}
+
+Core.prototype.getElapsed = function() {
+	Polycode.Core_getElapsed(this.__ptr)
+}
+
+Core.prototype.getTicks = function() {
+	Polycode.Core_getTicks(this.__ptr)
+}
+
+Core.prototype.getRefreshIntervalMs = function() {
+	Polycode.Core_getRefreshIntervalMs(this.__ptr)
+}
+
+Core.prototype.getTimeSleptMs = function() {
+	Polycode.Core_getTimeSleptMs(this.__ptr)
+}
+
+Core.prototype.getFixedTimestep = function() {
+	Polycode.Core_getFixedTimestep(this.__ptr)
+}
+
+Core.prototype.getTicksFloat = function() {
+	Polycode.Core_getTicksFloat(this.__ptr)
+}
+
+Core.prototype.setUserPointer = function(ptr) {
+	Polycode.Core_setUserPointer(this.__ptr, ptr)
+}
+
+Core.prototype.getUserPointer = function() {
+	Polycode.Core_getUserPointer(this.__ptr)
+}
+
+Core.prototype.executeExternalCommand = function(command,args,inDirectory) {
+	Polycode.Core_executeExternalCommand(this.__ptr, command,args,inDirectory)
+}
+
+Core.prototype.getDefaultWorkingDirectory = function() {
+	Polycode.Core_getDefaultWorkingDirectory(this.__ptr)
+}
+
+Core.prototype.getUserHomeDirectory = function() {
+	Polycode.Core_getUserHomeDirectory(this.__ptr)
+}
+
+Core.prototype.makeApplicationMain = function() {
+	Polycode.Core_makeApplicationMain(this.__ptr)
+}
+
+Core.prototype.getEventMutex = function() {
+	Polycode.Core_getEventMutex(this.__ptr)
+}
+
+Core.prototype.removeThread = function(thread) {
+	Polycode.Core_removeThread(this.__ptr, thread)
+}

bindings/javascript/Polycode/CoreFileExtension.js

@@ -0,0 +1,2 @@
+function CoreFileExtension() {
+}

bindings/javascript/Polycode/CoreInput.js

@@ -0,0 +1,98 @@
+function CoreInput() {
+}
+
+CoreInput.prototype.getMousePosition = function() {
+	Polycode.CoreInput_getMousePosition(this.__ptr)
+}
+
+CoreInput.prototype.getKeyState = function(keyCode) {
+	Polycode.CoreInput_getKeyState(this.__ptr, keyCode)
+}
+
+CoreInput.prototype.getJoystickButtonState = function(joystickIndex,button) {
+	Polycode.CoreInput_getJoystickButtonState(this.__ptr, joystickIndex,button)
+}
+
+CoreInput.prototype.getJoystickAxisValue = function(joystickIndex,axis) {
+	Polycode.CoreInput_getJoystickAxisValue(this.__ptr, joystickIndex,axis)
+}
+
+CoreInput.prototype.getMouseDelta = function() {
+	Polycode.CoreInput_getMouseDelta(this.__ptr)
+}
+
+CoreInput.prototype.getMouseButtonState = function(mouseButton) {
+	Polycode.CoreInput_getMouseButtonState(this.__ptr, mouseButton)
+}
+
+CoreInput.prototype.getNumJoysticks = function() {
+	Polycode.CoreInput_getNumJoysticks(this.__ptr)
+}
+
+CoreInput.prototype.getJoystickInfoByIndex = function(index) {
+	Polycode.CoreInput_getJoystickInfoByIndex(this.__ptr, index)
+}
+
+CoreInput.prototype.getJoystickInfoByID = function(deviceID) {
+	Polycode.CoreInput_getJoystickInfoByID(this.__ptr, deviceID)
+}
+
+CoreInput.prototype.addJoystick = function(deviceID) {
+	Polycode.CoreInput_addJoystick(this.__ptr, deviceID)
+}
+
+CoreInput.prototype.removeJoystick = function(deviceID) {
+	Polycode.CoreInput_removeJoystick(this.__ptr, deviceID)
+}
+
+CoreInput.prototype.joystickAxisMoved = function(axisID,value,deviceID) {
+	Polycode.CoreInput_joystickAxisMoved(this.__ptr, axisID,value,deviceID)
+}
+
+CoreInput.prototype.joystickButtonDown = function(buttonID,deviceID) {
+	Polycode.CoreInput_joystickButtonDown(this.__ptr, buttonID,deviceID)
+}
+
+CoreInput.prototype.joystickButtonUp = function(buttonID,deviceID) {
+	Polycode.CoreInput_joystickButtonUp(this.__ptr, buttonID,deviceID)
+}
+
+CoreInput.prototype.mouseWheelUp = function(ticks) {
+	Polycode.CoreInput_mouseWheelUp(this.__ptr, ticks)
+}
+
+CoreInput.prototype.mouseWheelDown = function(ticks) {
+	Polycode.CoreInput_mouseWheelDown(this.__ptr, ticks)
+}
+
+CoreInput.prototype.setMouseButtonState = function(mouseButton,state,ticks) {
+	Polycode.CoreInput_setMouseButtonState(this.__ptr, mouseButton,state,ticks)
+}
+
+CoreInput.prototype.setMousePosition = function(x,y,ticks) {
+	Polycode.CoreInput_setMousePosition(this.__ptr, x,y,ticks)
+}
+
+CoreInput.prototype.setKeyState = function(keyCode,code,newState,ticks) {
+	Polycode.CoreInput_setKeyState(this.__ptr, keyCode,code,newState,ticks)
+}
+
+CoreInput.prototype.setDeltaPosition = function(x,y) {
+	Polycode.CoreInput_setDeltaPosition(this.__ptr, x,y)
+}
+
+CoreInput.prototype.touchesBegan = function(touch,touches,ticks) {
+	Polycode.CoreInput_touchesBegan(this.__ptr, touch,touches,ticks)
+}
+
+CoreInput.prototype.touchesMoved = function(touch,touches,ticks) {
+	Polycode.CoreInput_touchesMoved(this.__ptr, touch,touches,ticks)
+}
+
+CoreInput.prototype.touchesEnded = function(touch,touches,ticks) {
+	Polycode.CoreInput_touchesEnded(this.__ptr, touch,touches,ticks)
+}
+
+CoreInput.prototype.clearInput = function() {
+	Polycode.CoreInput_clearInput(this.__ptr)
+}

bindings/javascript/Polycode/CoreMotionEvent.js

@@ -0,0 +1,2 @@
+function CoreMotionEvent() {
+}

bindings/javascript/Polycode/CoreMutex.js

@@ -0,0 +1,10 @@
+function CoreMutex() {
+}
+
+CoreMutex.prototype.lock = function() {
+	Polycode.CoreMutex_lock(this.__ptr)
+}
+
+CoreMutex.prototype.unlock = function() {
+	Polycode.CoreMutex_unlock(this.__ptr)
+}

bindings/javascript/Polycode/CoreServices.js

@@ -0,0 +1,66 @@
+function CoreServices() {
+}
+
+CoreServices.prototype.setRenderer = function(renderer) {
+	Polycode.CoreServices_setRenderer(this.__ptr, renderer)
+}
+
+CoreServices.prototype.getRenderer = function() {
+	Polycode.CoreServices_getRenderer(this.__ptr)
+}
+
+CoreServices.prototype.Update = function(elapsed) {
+	Polycode.CoreServices_Update(this.__ptr, elapsed)
+}
+
+CoreServices.prototype.fixedUpdate = function() {
+	Polycode.CoreServices_fixedUpdate(this.__ptr)
+}
+
+CoreServices.prototype.Render = function(viewport) {
+	Polycode.CoreServices_Render(this.__ptr, viewport)
+}
+
+CoreServices.prototype.setCore = function(core) {
+	Polycode.CoreServices_setCore(this.__ptr, core)
+}
+
+CoreServices.prototype.getCore = function() {
+	Polycode.CoreServices_getCore(this.__ptr)
+}
+
+CoreServices.prototype.getInput = function() {
+	Polycode.CoreServices_getInput(this.__ptr)
+}
+
+CoreServices.prototype.getMaterialManager = function() {
+	Polycode.CoreServices_getMaterialManager(this.__ptr)
+}
+
+CoreServices.prototype.getSceneManager = function() {
+	Polycode.CoreServices_getSceneManager(this.__ptr)
+}
+
+CoreServices.prototype.getTimerManager = function() {
+	Polycode.CoreServices_getTimerManager(this.__ptr)
+}
+
+CoreServices.prototype.getTweenManager = function() {
+	Polycode.CoreServices_getTweenManager(this.__ptr)
+}
+
+CoreServices.prototype.getResourceManager = function() {
+	Polycode.CoreServices_getResourceManager(this.__ptr)
+}
+
+CoreServices.prototype.getSoundManager = function() {
+	Polycode.CoreServices_getSoundManager(this.__ptr)
+}
+
+CoreServices.prototype.getLogger = function() {
+	Polycode.CoreServices_getLogger(this.__ptr)
+}
+
+CoreServices.prototype.getConfig = function() {
+	Polycode.CoreServices_getConfig(this.__ptr)
+}

bindings/javascript/Polycode/Cubemap.js

@@ -0,0 +1,14 @@
+function Cubemap() {
+}
+
+Cubemap.prototype.getTexture = function(index) {
+	Polycode.Cubemap_getTexture(this.__ptr, index)
+}
+
+Cubemap.prototype.setTexture = function(texture,index) {
+	Polycode.Cubemap_setTexture(this.__ptr, texture,index)
+}
+
+Cubemap.prototype.recreateFromTextures = function() {
+	Polycode.Cubemap_recreateFromTextures(this.__ptr)
+}

bindings/javascript/Polycode/Data.js

@@ -0,0 +1,22 @@
+function Data() {
+}
+
+Data.prototype.loadFromFile = function(fileName) {
+	Polycode.Data_loadFromFile(this.__ptr, fileName)
+}
+
+Data.prototype.getAsString = function(encoding) {
+	Polycode.Data_getAsString(this.__ptr, encoding)
+}
+
+Data.prototype.setFromString = function(str,encoding) {
+	Polycode.Data_setFromString(this.__ptr, str,encoding)
+}
+
+Data.prototype.saveToFile = function(fileName) {
+	Polycode.Data_saveToFile(this.__ptr, fileName)
+}
+
+Data.prototype.getData = function() {
+	Polycode.Data_getData(this.__ptr)
+}

bindings/javascript/Polycode/DebugBackTraceEntry.js

@@ -0,0 +1,2 @@
+function DebugBackTraceEntry() {
+}

bindings/javascript/Polycode/DummyCore.js

@@ -0,0 +1,82 @@
+function DummyCore() {
+}
+
+DummyCore.prototype.Render = function() {
+	Polycode.DummyCore_Render(this.__ptr)
+}
+
+DummyCore.prototype.systemUpdate = function() {
+	Polycode.DummyCore_systemUpdate(this.__ptr)
+}
+
+DummyCore.prototype.setCursor = function(cursorType) {
+	Polycode.DummyCore_setCursor(this.__ptr, cursorType)
+}
+
+DummyCore.prototype.createThread = function(target) {
+	Polycode.DummyCore_createThread(this.__ptr, target)
+}
+
+DummyCore.prototype.createMutex = function() {
+	Polycode.DummyCore_createMutex(this.__ptr)
+}
+
+DummyCore.prototype.copyStringToClipboard = function(str) {
+	Polycode.DummyCore_copyStringToClipboard(this.__ptr, str)
+}
+
+DummyCore.prototype.getClipboardString = function() {
+	Polycode.DummyCore_getClipboardString(this.__ptr)
+}
+
+DummyCore.prototype.createFolder = function(folderPath) {
+	Polycode.DummyCore_createFolder(this.__ptr, folderPath)
+}
+
+DummyCore.prototype.copyDiskItem = function(itemPath,destItemPath) {
+	Polycode.DummyCore_copyDiskItem(this.__ptr, itemPath,destItemPath)
+}
+
+DummyCore.prototype.moveDiskItem = function(itemPath,destItemPath) {
+	Polycode.DummyCore_moveDiskItem(this.__ptr, itemPath,destItemPath)
+}
+
+DummyCore.prototype.removeDiskItem = function(itemPath) {
+	Polycode.DummyCore_removeDiskItem(this.__ptr, itemPath)
+}
+
+DummyCore.prototype.openFolderPicker = function() {
+	Polycode.DummyCore_openFolderPicker(this.__ptr)
+}
+
+DummyCore.prototype.openFilePicker = function(extensions,allowMultiple) {
+	Polycode.DummyCore_openFilePicker(this.__ptr, extensions,allowMultiple)
+}
+
+DummyCore.prototype.saveFilePicker = function(extensions) {
+	Polycode.DummyCore_saveFilePicker(this.__ptr, extensions)
+}
+
+DummyCore.prototype.handleVideoModeChange = function(modeInfo) {
+	Polycode.DummyCore_handleVideoModeChange(this.__ptr, modeInfo)
+}
+
+DummyCore.prototype.flushRenderContext = function() {
+	Polycode.DummyCore_flushRenderContext(this.__ptr)
+}
+
+DummyCore.prototype.openURL = function(url) {
+	Polycode.DummyCore_openURL(this.__ptr, url)
+}
+
+DummyCore.prototype.getTicks = function() {
+	Polycode.DummyCore_getTicks(this.__ptr)
+}
+
+DummyCore.prototype.executeExternalCommand = function(command,args,inDirectory) {
+	Polycode.DummyCore_executeExternalCommand(this.__ptr, command,args,inDirectory)
+}
+
+DummyCore.prototype.systemParseFolder = function(pathString,showHidden,targetVector) {
+	Polycode.DummyCore_systemParseFolder(this.__ptr, pathString,showHidden,targetVector)
+}

bindings/javascript/Polycode/Entity.js

@@ -0,0 +1,478 @@
+function Entity() {
+}
+
+Entity.prototype.initEntity = function() {
+	Polycode.Entity_initEntity(this.__ptr)
+}
+
+Entity.prototype.Render = function(buffer) {
+	Polycode.Entity_Render(this.__ptr, buffer)
+}
+
+Entity.prototype.Update = function() {
+	Polycode.Entity_Update(this.__ptr)
+}
+
+Entity.prototype.fixedUpdate = function() {
+	Polycode.Entity_fixedUpdate(this.__ptr)
+}
+
+Entity.prototype.transformAndRender = function(drawBuffer,parentScissorBox) {
+	Polycode.Entity_transformAndRender(this.__ptr, drawBuffer,parentScissorBox)
+}
+
+Entity.prototype.renderChildren = function(buffer,parentScissorBox) {
+	Polycode.Entity_renderChildren(this.__ptr, buffer,parentScissorBox)
+}
+
+Entity.prototype.Clone = function(deepClone,ignoreEditorOnly) {
+	Polycode.Entity_Clone(this.__ptr, deepClone,ignoreEditorOnly)
+}
+
+Entity.prototype.applyClone = function(clone,deepClone,ignoreEditorOnly) {
+	Polycode.Entity_applyClone(this.__ptr, clone,deepClone,ignoreEditorOnly)
+}
+
+Entity.prototype.dirtyMatrix = function(val) {
+	Polycode.Entity_dirtyMatrix(this.__ptr, val)
+}
+
+Entity.prototype.rebuildTransformMatrix = function() {
+	Polycode.Entity_rebuildTransformMatrix(this.__ptr)
+}
+
+Entity.prototype.updateEntityMatrix = function() {
+	Polycode.Entity_updateEntityMatrix(this.__ptr)
+}
+
+Entity.prototype.getTransformMatrix = function() {
+	Polycode.Entity_getTransformMatrix(this.__ptr)
+}
+
+Entity.prototype.getConcatenatedMatrix = function() {
+	Polycode.Entity_getConcatenatedMatrix(this.__ptr)
+}
+
+Entity.prototype.getConcatenatedMatrixRelativeTo = function(relativeEntity) {
+	Polycode.Entity_getConcatenatedMatrixRelativeTo(this.__ptr, relativeEntity)
+}
+
+Entity.prototype.getAnchorAdjustedMatrix = function() {
+	Polycode.Entity_getAnchorAdjustedMatrix(this.__ptr)
+}
+
+Entity.prototype.getConcatenatedRollMatrix = function() {
+	Polycode.Entity_getConcatenatedRollMatrix(this.__ptr)
+}
+
+Entity.prototype.setTransformByMatrixPure = function(matrix) {
+	Polycode.Entity_setTransformByMatrixPure(this.__ptr, matrix)
+}
+
+Entity.prototype.getLookAtMatrix = function(loc,upVector) {
+	Polycode.Entity_getLookAtMatrix(this.__ptr, loc,upVector)
+}
+
+Entity.prototype.addChild = function(newChild) {
+	Polycode.Entity_addChild(this.__ptr, newChild)
+}
+
+Entity.prototype.removeChild = function(entityToRemove) {
+	Polycode.Entity_removeChild(this.__ptr, entityToRemove)
+}
+
+Entity.prototype.moveChildUp = function(child) {
+	Polycode.Entity_moveChildUp(this.__ptr, child)
+}
+
+Entity.prototype.moveChildDown = function(child) {
+	Polycode.Entity_moveChildDown(this.__ptr, child)
+}
+
+Entity.prototype.moveChildTop = function(child) {
+	Polycode.Entity_moveChildTop(this.__ptr, child)
+}
+
+Entity.prototype.moveChildBottom = function(child) {
+	Polycode.Entity_moveChildBottom(this.__ptr, child)
+}
+
+Entity.prototype.setParentEntity = function(entity) {
+	Polycode.Entity_setParentEntity(this.__ptr, entity)
+}
+
+Entity.prototype.getParentEntity = function() {
+	Polycode.Entity_getParentEntity(this.__ptr)
+}
+
+Entity.prototype.getNumChildren = function() {
+	Polycode.Entity_getNumChildren(this.__ptr)
+}
+
+Entity.prototype.getChildAtIndex = function(index) {
+	Polycode.Entity_getChildAtIndex(this.__ptr, index)
+}
+
+Entity.prototype.setOwnsChildrenRecursive = function(val) {
+	Polycode.Entity_setOwnsChildrenRecursive(this.__ptr, val)
+}
+
+Entity.prototype.getPosition = function() {
+	Polycode.Entity_getPosition(this.__ptr)
+}
+
+Entity.prototype.getPosition2D = function() {
+	Polycode.Entity_getPosition2D(this.__ptr)
+}
+
+Entity.prototype.getCombinedPosition = function() {
+	Polycode.Entity_getCombinedPosition(this.__ptr)
+}
+
+Entity.prototype.setPosition = function(x,y,z) {
+	Polycode.Entity_setPosition(this.__ptr, x,y,z)
+}
+
+Entity.prototype.setPositionX = function(x) {
+	Polycode.Entity_setPositionX(this.__ptr, x)
+}
+
+Entity.prototype.setPositionY = function(y) {
+	Polycode.Entity_setPositionY(this.__ptr, y)
+}
+
+Entity.prototype.Translate = function(x,y,z) {
+	Polycode.Entity_Translate(this.__ptr, x,y,z)
+}
+
+Entity.prototype.setPositionZ = function(z) {
+	Polycode.Entity_setPositionZ(this.__ptr, z)
+}
+
+Entity.prototype.setScaleX = function(x) {
+	Polycode.Entity_setScaleX(this.__ptr, x)
+}
+
+Entity.prototype.setScaleY = function(y) {
+	Polycode.Entity_setScaleY(this.__ptr, y)
+}
+
+Entity.prototype.setScaleZ = function(z) {
+	Polycode.Entity_setScaleZ(this.__ptr, z)
+}
+
+Entity.prototype.Scale = function(x,y,z) {
+	Polycode.Entity_Scale(this.__ptr, x,y,z)
+}
+
+Entity.prototype.setScale = function(x,y,z) {
+	Polycode.Entity_setScale(this.__ptr, x,y,z)
+}
+
+Entity.prototype.getCompoundScale = function() {
+	Polycode.Entity_getCompoundScale(this.__ptr)
+}
+
+Entity.prototype.getScale = function() {
+	Polycode.Entity_getScale(this.__ptr)
+}
+
+Entity.prototype.getRotationEuler = function() {
+	Polycode.Entity_getRotationEuler(this.__ptr)
+}
+
+Entity.prototype.getCombinedPitch = function() {
+	Polycode.Entity_getCombinedPitch(this.__ptr)
+}
+
+Entity.prototype.getCombinedYaw = function() {
+	Polycode.Entity_getCombinedYaw(this.__ptr)
+}
+
+Entity.prototype.getCombinedRoll = function() {
+	Polycode.Entity_getCombinedRoll(this.__ptr)
+}
+
+Entity.prototype.rebuildRotation = function() {
+	Polycode.Entity_rebuildRotation(this.__ptr)
+}
+
+Entity.prototype.setRotationEuler = function(rotation) {
+	Polycode.Entity_setRotationEuler(this.__ptr, rotation)
+}
+
+Entity.prototype.setPitch = function(pitch) {
+	Polycode.Entity_setPitch(this.__ptr, pitch)
+}
+
+Entity.prototype.setYaw = function(yaw) {
+	Polycode.Entity_setYaw(this.__ptr, yaw)
+}
+
+Entity.prototype.setRoll = function(roll) {
+	Polycode.Entity_setRoll(this.__ptr, roll)
+}
+
+Entity.prototype.Roll = function(roll) {
+	Polycode.Entity_Roll(this.__ptr, roll)
+}
+
+Entity.prototype.Yaw = function(yaw) {
+	Polycode.Entity_Yaw(this.__ptr, yaw)
+}
+
+Entity.prototype.Pitch = function(pitch) {
+	Polycode.Entity_Pitch(this.__ptr, pitch)
+}
+
+Entity.prototype.getPitch = function() {
+	Polycode.Entity_getPitch(this.__ptr)
+}
+
+Entity.prototype.getYaw = function() {
+	Polycode.Entity_getYaw(this.__ptr)
+}
+
+Entity.prototype.getRoll = function() {
+	Polycode.Entity_getRoll(this.__ptr)
+}
+
+Entity.prototype.getWidth = function() {
+	Polycode.Entity_getWidth(this.__ptr)
+}
+
+Entity.prototype.getHeight = function() {
+	Polycode.Entity_getHeight(this.__ptr)
+}
+
+Entity.prototype.getDepth = function() {
+	Polycode.Entity_getDepth(this.__ptr)
+}
+
+Entity.prototype.setWidth = function(width) {
+	Polycode.Entity_setWidth(this.__ptr, width)
+}
+
+Entity.prototype.setHeight = function(height) {
+	Polycode.Entity_setHeight(this.__ptr, height)
+}
+
+Entity.prototype.setDepth = function(depth) {
+	Polycode.Entity_setDepth(this.__ptr, depth)
+}
+
+Entity.prototype.setRotationQuat = function(w,x,y,z) {
+	Polycode.Entity_setRotationQuat(this.__ptr, w,x,y,z)
+}
+
+Entity.prototype.setRotationByQuaternion = function(quaternion) {
+	Polycode.Entity_setRotationByQuaternion(this.__ptr, quaternion)
+}
+
+Entity.prototype.getRotationQuat = function() {
+	Polycode.Entity_getRotationQuat(this.__ptr)
+}
+
+Entity.prototype.getConcatenatedQuat = function() {
+	Polycode.Entity_getConcatenatedQuat(this.__ptr)
+}
+
+Entity.prototype.lookAt = function(loc,upVector) {
+	Polycode.Entity_lookAt(this.__ptr, loc,upVector)
+}
+
+Entity.prototype.lookAtEntity = function(entity,upVector) {
+	Polycode.Entity_lookAtEntity(this.__ptr, entity,upVector)
+}
+
+Entity.prototype.getCombinedColor = function() {
+	Polycode.Entity_getCombinedColor(this.__ptr)
+}
+
+Entity.prototype.setColor = function(r,g,b,a) {
+	Polycode.Entity_setColor(this.__ptr, r,g,b,a)
+}
+
+Entity.prototype.setColorInt = function(r,g,b,a) {
+	Polycode.Entity_setColorInt(this.__ptr, r,g,b,a)
+}
+
+Entity.prototype.setAnchorPoint = function(anchorPoint) {
+	Polycode.Entity_setAnchorPoint(this.__ptr, anchorPoint)
+}
+
+Entity.prototype.getAnchorPoint = function() {
+	Polycode.Entity_getAnchorPoint(this.__ptr)
+}
+
+Entity.prototype.onMouseDown = function(ray,mouseButton,timestamp) {
+	Polycode.Entity_onMouseDown(this.__ptr, ray,mouseButton,timestamp)
+}
+
+Entity.prototype.onMouseUp = function(ray,mouseButton,timestamp) {
+	Polycode.Entity_onMouseUp(this.__ptr, ray,mouseButton,timestamp)
+}
+
+Entity.prototype.onMouseMove = function(ray,timestamp) {
+	Polycode.Entity_onMouseMove(this.__ptr, ray,timestamp)
+}
+
+Entity.prototype.onMouseWheelUp = function(ray,timestamp) {
+	Polycode.Entity_onMouseWheelUp(this.__ptr, ray,timestamp)
+}
+
+Entity.prototype.onMouseWheelDown = function(ray,timestamp) {
+	Polycode.Entity_onMouseWheelDown(this.__ptr, ray,timestamp)
+}
+
+Entity.prototype.setDepthOnly = function(val) {
+	Polycode.Entity_setDepthOnly(this.__ptr, val)
+}
+
+Entity.prototype.getDepthOnly = function() {
+	Polycode.Entity_getDepthOnly(this.__ptr)
+}
+
+Entity.prototype.setUserData = function(userData) {
+	Polycode.Entity_setUserData(this.__ptr, userData)
+}
+
+Entity.prototype.getUserData = function() {
+	Polycode.Entity_getUserData(this.__ptr)
+}
+
+Entity.prototype.setBlendingMode = function(newBlendingMode) {
+	Polycode.Entity_setBlendingMode(this.__ptr, newBlendingMode)
+}
+
+Entity.prototype.getBlendingMode = function() {
+	Polycode.Entity_getBlendingMode(this.__ptr)
+}
+
+Entity.prototype.getEntityById = function(id,recursive) {
+	Polycode.Entity_getEntityById(this.__ptr, id,recursive)
+}
+
+Entity.prototype.getEntitiesByTag = function(tag,recursive) {
+	Polycode.Entity_getEntitiesByTag(this.__ptr, tag,recursive)
+}
+
+Entity.prototype.getEntitiesByLayerID = function(layerID,recursive) {
+	Polycode.Entity_getEntitiesByLayerID(this.__ptr, layerID,recursive)
+}
+
+Entity.prototype.getEntityProp = function(propName) {
+	Polycode.Entity_getEntityProp(this.__ptr, propName)
+}
+
+Entity.prototype.setEntityProp = function(propName,propValue) {
+	Polycode.Entity_setEntityProp(this.__ptr, propName,propValue)
+}
+
+Entity.prototype.setInverseY = function(val) {
+	Polycode.Entity_setInverseY(this.__ptr, val)
+}
+
+Entity.prototype.getInverseY = function() {
+	Polycode.Entity_getInverseY(this.__ptr)
+}
+
+Entity.prototype.doUpdates = function() {
+	Polycode.Entity_doUpdates(this.__ptr)
+}
+
+Entity.prototype.doFixedUpdates = function() {
+	Polycode.Entity_doFixedUpdates(this.__ptr)
+}
+
+Entity.prototype.buildPositionMatrix = function() {
+	Polycode.Entity_buildPositionMatrix(this.__ptr)
+}
+
+Entity.prototype.setRenderer = function(renderer) {
+	Polycode.Entity_setRenderer(this.__ptr, renderer)
+}
+
+Entity.prototype.customHitDetection = function(ray) {
+	Polycode.Entity_customHitDetection(this.__ptr, ray)
+}
+
+Entity.prototype.getNumTags = function() {
+	Polycode.Entity_getNumTags(this.__ptr)
+}
+
+Entity.prototype.getTagAtIndex = function(index) {
+	Polycode.Entity_getTagAtIndex(this.__ptr, index)
+}
+
+Entity.prototype.hasTag = function(tag) {
+	Polycode.Entity_hasTag(this.__ptr, tag)
+}
+
+Entity.prototype.clearTags = function() {
+	Polycode.Entity_clearTags(this.__ptr)
+}
+
+Entity.prototype.addTag = function(tag) {
+	Polycode.Entity_addTag(this.__ptr, tag)
+}
+
+Entity.prototype.getScreenPosition = function(projectionMatrix,cameraMatrix,viewport) {
+	Polycode.Entity_getScreenPosition(this.__ptr, projectionMatrix,cameraMatrix,viewport)
+}
+
+Entity.prototype.recalculateAABBAllChildren = function() {
+	Polycode.Entity_recalculateAABBAllChildren(this.__ptr)
+}
+
+Entity.prototype.recalculateAABB = function() {
+	Polycode.Entity_recalculateAABB(this.__ptr)
+}
+
+Entity.prototype.getWorldAABB = function() {
+	Polycode.Entity_getWorldAABB(this.__ptr)
+}
+
+Entity.prototype.getLocalBoundingBox = function() {
+	Polycode.Entity_getLocalBoundingBox(this.__ptr)
+}
+
+Entity.prototype.setLocalBoundingBox = function(box) {
+	Polycode.Entity_setLocalBoundingBox(this.__ptr, box)
+}
+
+Entity.prototype.setLocalBoundingBoxX = function(x) {
+	Polycode.Entity_setLocalBoundingBoxX(this.__ptr, x)
+}
+
+Entity.prototype.setLocalBoundingBoxY = function(y) {
+	Polycode.Entity_setLocalBoundingBoxY(this.__ptr, y)
+}
+
+Entity.prototype.setLocalBoundingBoxZ = function(z) {
+	Polycode.Entity_setLocalBoundingBoxZ(this.__ptr, z)
+}
+
+Entity.prototype.setContainerScene = function(scene) {
+	Polycode.Entity_setContainerScene(this.__ptr, scene)
+}
+
+Entity.prototype.getContainerScene = function() {
+	Polycode.Entity_getContainerScene(this.__ptr)
+}
+
+Entity.prototype.attachScript = function(script) {
+	Polycode.Entity_attachScript(this.__ptr, script)
+}
+
+Entity.prototype.detachScript = function(script) {
+	Polycode.Entity_detachScript(this.__ptr, script)
+}
+
+Entity.prototype.getNumScripts = function() {
+	Polycode.Entity_getNumScripts(this.__ptr)
+}
+
+Entity.prototype.getScriptAtIndex = function(index) {
+	Polycode.Entity_getScriptAtIndex(this.__ptr, index)
+}

bindings/javascript/Polycode/EntityProp.js

@@ -0,0 +1,2 @@
+function EntityProp() {
+}

bindings/javascript/Polycode/Event.js

@@ -0,0 +1,26 @@
+function Event() {
+}
+
+Event.prototype.getEventCode = function() {
+	Polycode.Event_getEventCode(this.__ptr)
+}
+
+Event.prototype.getDispatcher = function() {
+	Polycode.Event_getDispatcher(this.__ptr)
+}
+
+Event.prototype.setEventCode = function(eventCode) {
+	Polycode.Event_setEventCode(this.__ptr, eventCode)
+}
+
+Event.prototype.setDispatcher = function(dispatcher) {
+	Polycode.Event_setDispatcher(this.__ptr, dispatcher)
+}
+
+Event.prototype.getEventType = function() {
+	Polycode.Event_getEventType(this.__ptr)
+}
+
+Event.prototype.cancelEvent = function() {
+	Polycode.Event_cancelEvent(this.__ptr)
+}

bindings/javascript/Polycode/EventDispatcher.js

@@ -0,0 +1,38 @@
+function EventDispatcher() {
+}
+
+EventDispatcher.prototype.removeAllHandlers = function() {
+	Polycode.EventDispatcher_removeAllHandlers(this.__ptr)
+}
+
+EventDispatcher.prototype.removeAllHandlersForListener = function(handler) {
+	Polycode.EventDispatcher_removeAllHandlersForListener(this.__ptr, handler)
+}
+
+EventDispatcher.prototype.addEventListener = function(handler,eventCode) {
+	Polycode.EventDispatcher_addEventListener(this.__ptr, handler,eventCode)
+}
+
+EventDispatcher.prototype.addEventListenerUnique = function(handler,eventCode) {
+	Polycode.EventDispatcher_addEventListenerUnique(this.__ptr, handler,eventCode)
+}
+
+EventDispatcher.prototype.hasEventListener = function(handler,eventCode) {
+	Polycode.EventDispatcher_hasEventListener(this.__ptr, handler,eventCode)
+}
+
+EventDispatcher.prototype.removeEventListener = function(handler,eventCode) {
+	Polycode.EventDispatcher_removeEventListener(this.__ptr, handler,eventCode)
+}
+
+EventDispatcher.prototype.__dispatchEvent = function(event,eventCode) {
+	Polycode.EventDispatcher___dispatchEvent(this.__ptr, event,eventCode)
+}
+
+EventDispatcher.prototype.dispatchEvent = function(event,eventCode) {
+	Polycode.EventDispatcher_dispatchEvent(this.__ptr, event,eventCode)
+}
+
+EventDispatcher.prototype.dispatchEventNoDelete = function(event,eventCode) {
+	Polycode.EventDispatcher_dispatchEventNoDelete(this.__ptr, event,eventCode)
+}

bindings/javascript/Polycode/EventHandler.js

@@ -0,0 +1,2 @@
+function EventHandler() {
+}

bindings/javascript/Polycode/Font.js

@@ -0,0 +1,22 @@
+function Font() {
+}
+
+Font.prototype.getFace = function() {
+	Polycode.Font_getFace(this.__ptr)
+}
+
+Font.prototype.isValid = function() {
+	Polycode.Font_isValid(this.__ptr)
+}
+
+Font.prototype.setFontName = function(fontName) {
+	Polycode.Font_setFontName(this.__ptr, fontName)
+}
+
+Font.prototype.getFontName = function() {
+	Polycode.Font_getFontName(this.__ptr)
+}
+
+Font.prototype.getFontPath = function() {
+	Polycode.Font_getFontPath(this.__ptr)
+}

bindings/javascript/Polycode/FontResourceLoader.js

@@ -0,0 +1,6 @@
+function FontResourceLoader() {
+}
+
+FontResourceLoader.prototype.loadResource = function(path,targetPool) {
+	Polycode.FontResourceLoader_loadResource(this.__ptr, path,targetPool)
+}

bindings/javascript/Polycode/GPUDrawBuffer.js

@@ -0,0 +1,2 @@
+function GPUDrawBuffer() {
+}

bindings/javascript/Polycode/GPUDrawCall.js

@@ -0,0 +1,2 @@
+function GPUDrawCall() {
+}

bindings/javascript/Polycode/GPUDrawOptions.js

@@ -0,0 +1,2 @@
+function GPUDrawOptions() {
+}

bindings/javascript/Polycode/GlyphData.js

@@ -0,0 +1,6 @@
+function GlyphData() {
+}
+
+GlyphData.prototype.clearData = function() {
+	Polycode.GlyphData_clearData(this.__ptr)
+}

bindings/javascript/Polycode/Image.js

@@ -0,0 +1,114 @@
+function Image() {
+}
+
+Image.prototype.loadImage = function(fileName) {
+	Polycode.Image_loadImage(this.__ptr, fileName)
+}
+
+Image.prototype.saveImage = function(fileName) {
+	Polycode.Image_saveImage(this.__ptr, fileName)
+}
+
+Image.prototype.pasteImage = function(image,x,y,blendingMode,blendAmount,blendColor) {
+	Polycode.Image_pasteImage(this.__ptr, image,x,y,blendingMode,blendAmount,blendColor)
+}
+
+Image.prototype.createEmpty = function(width,height,fillColor) {
+	Polycode.Image_createEmpty(this.__ptr, width,height,fillColor)
+}
+
+Image.prototype.fill = function(color) {
+	Polycode.Image_fill(this.__ptr, color)
+}
+
+Image.prototype.setPixel = function(x,y,r,g,b,a) {
+	Polycode.Image_setPixel(this.__ptr, x,y,r,g,b,a)
+}
+
+Image.prototype.getPixel = function(x,y) {
+	Polycode.Image_getPixel(this.__ptr, x,y)
+}
+
+Image.prototype.swap = function(v1,v2) {
+	Polycode.Image_swap(this.__ptr, v1,v2)
+}
+
+Image.prototype.drawLine = function(x0,y0,x1,y1,col) {
+	Polycode.Image_drawLine(this.__ptr, x0,y0,x1,y1,col)
+}
+
+Image.prototype.moveBrushTo = function(x,y) {
+	Polycode.Image_moveBrushTo(this.__ptr, x,y)
+}
+
+Image.prototype.moveBrush = function(x,y) {
+	Polycode.Image_moveBrush(this.__ptr, x,y)
+}
+
+Image.prototype.drawLineTo = function(x,y,col) {
+	Polycode.Image_drawLineTo(this.__ptr, x,y,col)
+}
+
+Image.prototype.fillRect = function(x,y,w,h,col) {
+	Polycode.Image_fillRect(this.__ptr, x,y,w,h,col)
+}
+
+Image.prototype.perlinNoise = function(seed,alpha) {
+	Polycode.Image_perlinNoise(this.__ptr, seed,alpha)
+}
+
+Image.prototype.fastBlur = function(blurSize) {
+	Polycode.Image_fastBlur(this.__ptr, blurSize)
+}
+
+Image.prototype.fastBlurVert = function(blurSize) {
+	Polycode.Image_fastBlurVert(this.__ptr, blurSize)
+}
+
+Image.prototype.fastBlurHor = function(blurSize) {
+	Polycode.Image_fastBlurHor(this.__ptr, blurSize)
+}
+
+Image.prototype.getPixelsInRect = function(x,y,width,height) {
+	Polycode.Image_getPixelsInRect(this.__ptr, x,y,width,height)
+}
+
+Image.prototype.getImagePart = function(subRect) {
+	Polycode.Image_getImagePart(this.__ptr, subRect)
+}
+
+Image.prototype.getBrushX = function() {
+	Polycode.Image_getBrushX(this.__ptr)
+}
+
+Image.prototype.getBrushY = function() {
+	Polycode.Image_getBrushY(this.__ptr)
+}
+
+Image.prototype.isLoaded = function() {
+	Polycode.Image_isLoaded(this.__ptr)
+}
+
+Image.prototype.getType = function() {
+	Polycode.Image_getType(this.__ptr)
+}
+
+Image.prototype.getWidth = function() {
+	Polycode.Image_getWidth(this.__ptr)
+}
+
+Image.prototype.getHeight = function() {
+	Polycode.Image_getHeight(this.__ptr)
+}
+
+Image.prototype.getPixels = function() {
+	Polycode.Image_getPixels(this.__ptr)
+}
+
+Image.prototype.premultiplyAlpha = function() {
+	Polycode.Image_premultiplyAlpha(this.__ptr)
+}
+
+Image.prototype.savePNG = function(fileName) {
+	Polycode.Image_savePNG(this.__ptr, fileName)
+}

bindings/javascript/Polycode/IndexDataArray.js

@@ -0,0 +1,10 @@
+function IndexDataArray() {
+}
+
+IndexDataArray.prototype.getArrayData = function() {
+	Polycode.IndexDataArray_getArrayData(this.__ptr)
+}
+
+IndexDataArray.prototype.getDataSize = function() {
+	Polycode.IndexDataArray_getDataSize(this.__ptr)
+}

bindings/javascript/Polycode/InputEvent.js

@@ -0,0 +1,22 @@
+function InputEvent() {
+}
+
+InputEvent.prototype.getMousePosition = function() {
+	Polycode.InputEvent_getMousePosition(this.__ptr)
+}
+
+InputEvent.prototype.getKey = function() {
+	Polycode.InputEvent_getKey(this.__ptr)
+}
+
+InputEvent.prototype.getMouseButton = function() {
+	Polycode.InputEvent_getMouseButton(this.__ptr)
+}
+
+InputEvent.prototype.getCharCode = function() {
+	Polycode.InputEvent_getCharCode(this.__ptr)
+}
+
+InputEvent.prototype.keyCode = function() {
+	Polycode.InputEvent_keyCode(this.__ptr)
+}

bindings/javascript/Polycode/JSScriptInstance.js

@@ -0,0 +1,2 @@
+function JSScriptInstance() {
+}

bindings/javascript/Polycode/JoystickInfo.js

@@ -0,0 +1,2 @@
+function JoystickInfo() {
+}

bindings/javascript/Polycode/Label.js

@@ -0,0 +1,98 @@
+function Label() {
+}
+
+Label.prototype.setText = function(text) {
+	Polycode.Label_setText(this.__ptr, text)
+}
+
+Label.prototype.getText = function() {
+	Polycode.Label_getText(this.__ptr)
+}
+
+Label.prototype.getTextWidthForString = function(text) {
+	Polycode.Label_getTextWidthForString(this.__ptr, text)
+}
+
+Label.prototype.getTextHeightForString = function(text) {
+	Polycode.Label_getTextHeightForString(this.__ptr, text)
+}
+
+Label.prototype.getTextWidth = function() {
+	Polycode.Label_getTextWidth(this.__ptr)
+}
+
+Label.prototype.getTextHeight = function() {
+	Polycode.Label_getTextHeight(this.__ptr)
+}
+
+Label.prototype.setColorForRange = function(color,rangeStart,rangeEnd) {
+	Polycode.Label_setColorForRange(this.__ptr, color,rangeStart,rangeEnd)
+}
+
+Label.prototype.clearColors = function() {
+	Polycode.Label_clearColors(this.__ptr)
+}
+
+Label.prototype.getColorForIndex = function(index) {
+	Polycode.Label_getColorForIndex(this.__ptr, index)
+}
+
+Label.prototype.getPremultiplyAlpha = function() {
+	Polycode.Label_getPremultiplyAlpha(this.__ptr)
+}
+
+Label.prototype.setPremultiplyAlpha = function(val) {
+	Polycode.Label_setPremultiplyAlpha(this.__ptr, val)
+}
+
+Label.prototype.setFont = function(newFont) {
+	Polycode.Label_setFont(this.__ptr, newFont)
+}
+
+Label.prototype.getFont = function() {
+	Polycode.Label_getFont(this.__ptr)
+}
+
+Label.prototype.setSize = function(newSize) {
+	Polycode.Label_setSize(this.__ptr, newSize)
+}
+
+Label.prototype.getSize = function() {
+	Polycode.Label_getSize(this.__ptr)
+}
+
+Label.prototype.getAntialiasMode = function() {
+	Polycode.Label_getAntialiasMode(this.__ptr)
+}
+
+Label.prototype.setAntialiasMode = function(newMode) {
+	Polycode.Label_setAntialiasMode(this.__ptr, newMode)
+}
+
+Label.prototype.getBaselineAdjust = function() {
+	Polycode.Label_getBaselineAdjust(this.__ptr)
+}
+
+Label.prototype.setBackgroundColor = function(color) {
+	Polycode.Label_setBackgroundColor(this.__ptr, color)
+}
+
+Label.prototype.setForegroundColor = function(color) {
+	Polycode.Label_setForegroundColor(this.__ptr, color)
+}
+
+Label.prototype.setColors = function(backgroundColor,foregroundColor) {
+	Polycode.Label_setColors(this.__ptr, backgroundColor,foregroundColor)
+}
+
+Label.prototype.getBackgroundColor = function() {
+	Polycode.Label_getBackgroundColor(this.__ptr)
+}
+
+Label.prototype.getForegroundColor = function() {
+	Polycode.Label_getForegroundColor(this.__ptr)
+}
+
+Label.prototype.optionsChanged = function() {
+	Polycode.Label_optionsChanged(this.__ptr)
+}

bindings/javascript/Polycode/LightInfo.js

@@ -0,0 +1,2 @@
+function LightInfo() {
+}

bindings/javascript/Polycode/LightInfoBinding.js

@@ -0,0 +1,2 @@
+function LightInfoBinding() {
+}

bindings/javascript/Polycode/LightShadowInfoBinding.js

@@ -0,0 +1,2 @@
+function LightShadowInfoBinding() {
+}

bindings/javascript/Polycode/LocalShaderParam.js

@@ -0,0 +1,66 @@
+function LocalShaderParam() {
+}
+
+LocalShaderParam.prototype.Copy = function() {
+	Polycode.LocalShaderParam_Copy(this.__ptr)
+}
+
+LocalShaderParam.prototype.getNumber = function() {
+	Polycode.LocalShaderParam_getNumber(this.__ptr)
+}
+
+LocalShaderParam.prototype.getVector2 = function() {
+	Polycode.LocalShaderParam_getVector2(this.__ptr)
+}
+
+LocalShaderParam.prototype.getVector3 = function() {
+	Polycode.LocalShaderParam_getVector3(this.__ptr)
+}
+
+LocalShaderParam.prototype.getMatrix4 = function() {
+	Polycode.LocalShaderParam_getMatrix4(this.__ptr)
+}
+
+LocalShaderParam.prototype.getColor = function() {
+	Polycode.LocalShaderParam_getColor(this.__ptr)
+}
+
+LocalShaderParam.prototype.setNumber = function(x) {
+	Polycode.LocalShaderParam_setNumber(this.__ptr, x)
+}
+
+LocalShaderParam.prototype.setVector2 = function(x) {
+	Polycode.LocalShaderParam_setVector2(this.__ptr, x)
+}
+
+LocalShaderParam.prototype.setVector3 = function(x) {
+	Polycode.LocalShaderParam_setVector3(this.__ptr, x)
+}
+
+LocalShaderParam.prototype.setMatrix4 = function(x) {
+	Polycode.LocalShaderParam_setMatrix4(this.__ptr, x)
+}
+
+LocalShaderParam.prototype.setColor = function(x) {
+	Polycode.LocalShaderParam_setColor(this.__ptr, x)
+}
+
+LocalShaderParam.prototype.setTexture = function(texture) {
+	Polycode.LocalShaderParam_setTexture(this.__ptr, texture)
+}
+
+LocalShaderParam.prototype.getTexture = function() {
+	Polycode.LocalShaderParam_getTexture(this.__ptr)
+}
+
+LocalShaderParam.prototype.setCubemap = function(cubemap) {
+	Polycode.LocalShaderParam_setCubemap(this.__ptr, cubemap)
+}
+
+LocalShaderParam.prototype.getCubemap = function() {
+	Polycode.LocalShaderParam_getCubemap(this.__ptr)
+}
+
+LocalShaderParam.prototype.setParamValueFromString = function(type,pvalue) {
+	Polycode.LocalShaderParam_setParamValueFromString(this.__ptr, type,pvalue)
+}

bindings/javascript/Polycode/LuaScriptInstance.js

@@ -0,0 +1,2 @@
+function LuaScriptInstance() {
+}

bindings/javascript/Polycode/Material.js

@@ -0,0 +1,82 @@
+function Material() {
+}
+
+Material.prototype.addShaderPass = function(pass) {
+	Polycode.Material_addShaderPass(this.__ptr, pass)
+}
+
+Material.prototype.addShaderPassAtIndex = function(pass,shaderIndex) {
+	Polycode.Material_addShaderPassAtIndex(this.__ptr, pass,shaderIndex)
+}
+
+Material.prototype.addShader = function(shader,shaderBinding) {
+	Polycode.Material_addShader(this.__ptr, shader,shaderBinding)
+}
+
+Material.prototype.addShaderAtIndex = function(shader,shaderBinding,shaderIndex) {
+	Polycode.Material_addShaderAtIndex(this.__ptr, shader,shaderBinding,shaderIndex)
+}
+
+Material.prototype.getNumShaderPasses = function() {
+	Polycode.Material_getNumShaderPasses(this.__ptr)
+}
+
+Material.prototype.removeShaderPass = function(shaderIndex) {
+	Polycode.Material_removeShaderPass(this.__ptr, shaderIndex)
+}
+
+Material.prototype.recreateExpectedShaderParams = function() {
+	Polycode.Material_recreateExpectedShaderParams(this.__ptr)
+}
+
+Material.prototype.addShaderRenderTarget = function(newTarget) {
+	Polycode.Material_addShaderRenderTarget(this.__ptr, newTarget)
+}
+
+Material.prototype.getNumShaderRenderTargets = function() {
+	Polycode.Material_getNumShaderRenderTargets(this.__ptr)
+}
+
+Material.prototype.getShaderRenderTarget = function(index) {
+	Polycode.Material_getShaderRenderTarget(this.__ptr, index)
+}
+
+Material.prototype.removeShaderRenderTarget = function(index) {
+	Polycode.Material_removeShaderRenderTarget(this.__ptr, index)
+}
+
+Material.prototype.recreateRenderTarget = function(renderTarget) {
+	Polycode.Material_recreateRenderTarget(this.__ptr, renderTarget)
+}
+
+Material.prototype.recreateRenderTargets = function() {
+	Polycode.Material_recreateRenderTargets(this.__ptr)
+}
+
+Material.prototype.getName = function() {
+	Polycode.Material_getName(this.__ptr)
+}
+
+Material.prototype.getShaderPass = function(index) {
+	Polycode.Material_getShaderPass(this.__ptr, index)
+}
+
+Material.prototype.getShaderBinding = function(index) {
+	Polycode.Material_getShaderBinding(this.__ptr, index)
+}
+
+Material.prototype.getShader = function(index) {
+	Polycode.Material_getShader(this.__ptr, index)
+}
+
+Material.prototype.loadMaterial = function(fileName) {
+	Polycode.Material_loadMaterial(this.__ptr, fileName)
+}
+
+Material.prototype.setName = function(name) {
+	Polycode.Material_setName(this.__ptr, name)
+}
+
+Material.prototype.clearShaders = function() {
+	Polycode.Material_clearShaders(this.__ptr)
+}

bindings/javascript/Polycode/MaterialManager.js

@@ -0,0 +1,114 @@
+function MaterialManager() {
+}
+
+MaterialManager.prototype.Update = function(elapsed) {
+	Polycode.MaterialManager_Update(this.__ptr, elapsed)
+}
+
+MaterialManager.prototype.createTexture = function(width,height,imageData,clamp,createMipmaps,type) {
+	Polycode.MaterialManager_createTexture(this.__ptr, width,height,imageData,clamp,createMipmaps,type)
+}
+
+MaterialManager.prototype.createNewTexture = function(width,height,clamp,createMipmaps,type) {
+	Polycode.MaterialManager_createNewTexture(this.__ptr, width,height,clamp,createMipmaps,type)
+}
+
+MaterialManager.prototype.createTextureFromImage = function(image,clamp,createMipmaps) {
+	Polycode.MaterialManager_createTextureFromImage(this.__ptr, image,clamp,createMipmaps)
+}
+
+MaterialManager.prototype.createTextureFromFile = function(fileName,clamp,createMipmaps,resourcePool) {
+	Polycode.MaterialManager_createTextureFromFile(this.__ptr, fileName,clamp,createMipmaps,resourcePool)
+}
+
+MaterialManager.prototype.deleteTexture = function(texture) {
+	Polycode.MaterialManager_deleteTexture(this.__ptr, texture)
+}
+
+MaterialManager.prototype.reloadTextures = function() {
+	Polycode.MaterialManager_reloadTextures(this.__ptr)
+}
+
+MaterialManager.prototype.reloadProgramsAndTextures = function() {
+	Polycode.MaterialManager_reloadProgramsAndTextures(this.__ptr)
+}
+
+MaterialManager.prototype.reloadPrograms = function() {
+	Polycode.MaterialManager_reloadPrograms(this.__ptr)
+}
+
+MaterialManager.prototype.getTextureByResourcePath = function(resourcePath) {
+	Polycode.MaterialManager_getTextureByResourcePath(this.__ptr, resourcePath)
+}
+
+MaterialManager.prototype.createProgramFromFile = function(programPath) {
+	Polycode.MaterialManager_createProgramFromFile(this.__ptr, programPath)
+}
+
+MaterialManager.prototype.loadMaterialLibraryIntoPool = function(pool,materialFile) {
+	Polycode.MaterialManager_loadMaterialLibraryIntoPool(this.__ptr, pool,materialFile)
+}
+
+MaterialManager.prototype.cubemapFromXMLNode = function(node) {
+	Polycode.MaterialManager_cubemapFromXMLNode(this.__ptr, node)
+}
+
+MaterialManager.prototype.materialFromXMLNode = function(resourcePool,node) {
+	Polycode.MaterialManager_materialFromXMLNode(this.__ptr, resourcePool,node)
+}
+
+MaterialManager.prototype.createMaterial = function(resourcePool,materialName,shaderName) {
+	Polycode.MaterialManager_createMaterial(this.__ptr, resourcePool,materialName,shaderName)
+}
+
+MaterialManager.prototype.setShaderFromXMLNode = function(resourcePool,node) {
+	Polycode.MaterialManager_setShaderFromXMLNode(this.__ptr, resourcePool,node)
+}
+
+MaterialManager.prototype.createShaderFromXMLNode = function(resourcePool,node) {
+	Polycode.MaterialManager_createShaderFromXMLNode(this.__ptr, resourcePool,node)
+}
+
+MaterialManager.prototype.createShader = function(resourcePool,shaderType,name,vpName,fpName,screenShader) {
+	Polycode.MaterialManager_createShader(this.__ptr, resourcePool,shaderType,name,vpName,fpName,screenShader)
+}
+
+MaterialManager.prototype.loadMaterialsFromFile = function(resourcePool,fileName) {
+	Polycode.MaterialManager_loadMaterialsFromFile(this.__ptr, resourcePool,fileName)
+}
+
+MaterialManager.prototype.loadShadersFromFile = function(resourcePool,fileName) {
+	Polycode.MaterialManager_loadShadersFromFile(this.__ptr, resourcePool,fileName)
+}
+
+MaterialManager.prototype.loadCubemapsFromFile = function(fileName) {
+	Polycode.MaterialManager_loadCubemapsFromFile(this.__ptr, fileName)
+}
+
+MaterialManager.prototype.setAnisotropyAmount = function(anisotropy) {
+	Polycode.MaterialManager_setAnisotropyAmount(this.__ptr, anisotropy)
+}
+
+MaterialManager.prototype.setTextureFilteringMode = function(textureFilteringMode) {
+	Polycode.MaterialManager_setTextureFilteringMode(this.__ptr, textureFilteringMode)
+}
+
+MaterialManager.prototype.getTextureFilteringMode = function() {
+	Polycode.MaterialManager_getTextureFilteringMode(this.__ptr)
+}
+
+MaterialManager.prototype.addMaterial = function(material) {
+	Polycode.MaterialManager_addMaterial(this.__ptr, material)
+}
+
+MaterialManager.prototype.addShader = function(shader) {
+	Polycode.MaterialManager_addShader(this.__ptr, shader)
+}
+
+MaterialManager.prototype.getNumShaders = function() {
+	Polycode.MaterialManager_getNumShaders(this.__ptr)
+}
+
+MaterialManager.prototype.getShaderByIndex = function(index) {
+	Polycode.MaterialManager_getShaderByIndex(this.__ptr, index)
+}

bindings/javascript/Polycode/MaterialResourceLoader.js

@@ -0,0 +1,6 @@
+function MaterialResourceLoader() {
+}
+
+MaterialResourceLoader.prototype.loadResource = function(path,targetPool) {
+	Polycode.MaterialResourceLoader_loadResource(this.__ptr, path,targetPool)
+}

bindings/javascript/Polycode/Matrix4.js

@@ -0,0 +1,70 @@
+function Matrix4() {
+}
+
+Matrix4.prototype.identity = function() {
+	Polycode.Matrix4_identity(this.__ptr)
+}
+
+Matrix4.prototype.rotateVector = function(v2) {
+	Polycode.Matrix4_rotateVector(this.__ptr, v2)
+}
+
+Matrix4.prototype.getPosition = function() {
+	Polycode.Matrix4_getPosition(this.__ptr)
+}
+
+Matrix4.prototype.multiplyWithPerspective = function(v2) {
+	Polycode.Matrix4_multiplyWithPerspective(this.__ptr, v2)
+}
+
+Matrix4.prototype.multVector3 = function(v2) {
+	Polycode.Matrix4_multVector3(this.__ptr, v2)
+}
+
+Matrix4.prototype.multVector4 = function(v2) {
+	Polycode.Matrix4_multVector4(this.__ptr, v2)
+}
+
+Matrix4.prototype.Translate = function(x,y,z) {
+	Polycode.Matrix4_Translate(this.__ptr, x,y,z)
+}
+
+Matrix4.prototype.setPosition = function(x,y,z) {
+	Polycode.Matrix4_setPosition(this.__ptr, x,y,z)
+}
+
+Matrix4.prototype.setScale = function(scale) {
+	Polycode.Matrix4_setScale(this.__ptr, scale)
+}
+
+Matrix4.prototype.getEulerAngles = function(ax,ay,az) {
+	Polycode.Matrix4_getEulerAngles(this.__ptr, ax,ay,az)
+}
+
+Matrix4.prototype.transpose = function() {
+	Polycode.Matrix4_transpose(this.__ptr)
+}
+
+Matrix4.prototype.Inverse = function() {
+	Polycode.Matrix4_Inverse(this.__ptr)
+}
+
+Matrix4.prototype.inverseAffine = function() {
+	Polycode.Matrix4_inverseAffine(this.__ptr)
+}
+
+Matrix4.prototype.determinant = function() {
+	Polycode.Matrix4_determinant(this.__ptr)
+}
+
+Matrix4.prototype.setOrthoProjection = function(left,right,bottom,top,zNear,zFar) {
+	Polycode.Matrix4_setOrthoProjection(this.__ptr, left,right,bottom,top,zNear,zFar)
+}
+
+Matrix4.prototype.setProjectionFrustum = function(left,right,bottom,top,zNear,zFar) {
+	Polycode.Matrix4_setProjectionFrustum(this.__ptr, left,right,bottom,top,zNear,zFar)
+}
+
+Matrix4.prototype.setProjection = function(fov,aspect,zNear,zFar) {
+	Polycode.Matrix4_setProjection(this.__ptr, fov,aspect,zNear,zFar)
+}

bindings/javascript/Polycode/Mesh.js

@@ -0,0 +1,198 @@
+function Mesh() {
+}
+
+Mesh.prototype.loadMesh = function(fileName) {
+	Polycode.Mesh_loadMesh(this.__ptr, fileName)
+}
+
+Mesh.prototype.clearMesh = function() {
+	Polycode.Mesh_clearMesh(this.__ptr)
+}
+
+Mesh.prototype.saveToFile = function(fileName,writeNormals,writeTangents,writeColors,writeBoneWeights,writeUVs,writeSecondaryUVs) {
+	Polycode.Mesh_saveToFile(this.__ptr, fileName,writeNormals,writeTangents,writeColors,writeBoneWeights,writeUVs,writeSecondaryUVs)
+}
+
+Mesh.prototype.loadFromFile = function(inFile) {
+	Polycode.Mesh_loadFromFile(this.__ptr, inFile)
+}
+
+Mesh.prototype.getVertexCount = function() {
+	Polycode.Mesh_getVertexCount(this.__ptr)
+}
+
+Mesh.prototype.createPlane = function(w,h,tilingValue) {
+	Polycode.Mesh_createPlane(this.__ptr, w,h,tilingValue)
+}
+
+Mesh.prototype.createVPlane = function(w,h,tilingValue) {
+	Polycode.Mesh_createVPlane(this.__ptr, w,h,tilingValue)
+}
+
+Mesh.prototype.createCircle = function(w,h,numSegments,tilingValue) {
+	Polycode.Mesh_createCircle(this.__ptr, w,h,numSegments,tilingValue)
+}
+
+Mesh.prototype.createLineCircle = function(w,h,numSegments,tilingValue) {
+	Polycode.Mesh_createLineCircle(this.__ptr, w,h,numSegments,tilingValue)
+}
+
+Mesh.prototype.createTorus = function(radius,tubeRadius,segmentsW,segmentsH,tilingValue) {
+	Polycode.Mesh_createTorus(this.__ptr, radius,tubeRadius,segmentsW,segmentsH,tilingValue)
+}
+
+Mesh.prototype.createBox = function(w,d,h,tilingValue) {
+	Polycode.Mesh_createBox(this.__ptr, w,d,h,tilingValue)
+}
+
+Mesh.prototype.createSphere = function(radius,numRings,numSegments,tilingValue) {
+	Polycode.Mesh_createSphere(this.__ptr, radius,numRings,numSegments,tilingValue)
+}
+
+Mesh.prototype.createIcosphere = function(radius,subdivisions) {
+	Polycode.Mesh_createIcosphere(this.__ptr, radius,subdivisions)
+}
+
+Mesh.prototype.createOctosphere = function(radius,subdivisions) {
+	Polycode.Mesh_createOctosphere(this.__ptr, radius,subdivisions)
+}
+
+Mesh.prototype.createCylinder = function(height,radius,numSegments,capped,tilingValue) {
+	Polycode.Mesh_createCylinder(this.__ptr, height,radius,numSegments,capped,tilingValue)
+}
+
+Mesh.prototype.createCone = function(height,radius,numSegments,tilingValue) {
+	Polycode.Mesh_createCone(this.__ptr, height,radius,numSegments,tilingValue)
+}
+
+Mesh.prototype.recenterMesh = function() {
+	Polycode.Mesh_recenterMesh(this.__ptr)
+}
+
+Mesh.prototype.setVertexAtOffset = function(offset,x,y,z) {
+	Polycode.Mesh_setVertexAtOffset(this.__ptr, offset,x,y,z)
+}
+
+Mesh.prototype.addVertexWithUVAndNormal = function(x,y,z,u,v,nx,ny,nz) {
+	Polycode.Mesh_addVertexWithUVAndNormal(this.__ptr, x,y,z,u,v,nx,ny,nz)
+}
+
+Mesh.prototype.addTexCoord = function(u,v) {
+	Polycode.Mesh_addTexCoord(this.__ptr, u,v)
+}
+
+Mesh.prototype.addTexCoord2 = function(u,v) {
+	Polycode.Mesh_addTexCoord2(this.__ptr, u,v)
+}
+
+Mesh.prototype.addTangent = function(x,y,z) {
+	Polycode.Mesh_addTangent(this.__ptr, x,y,z)
+}
+
+Mesh.prototype.addVertexWithUV = function(x,y,z,u,v) {
+	Polycode.Mesh_addVertexWithUV(this.__ptr, x,y,z,u,v)
+}
+
+Mesh.prototype.addVertex = function(x,y,z) {
+	Polycode.Mesh_addVertex(this.__ptr, x,y,z)
+}
+
+Mesh.prototype.addNormal = function(nx,ny,nz) {
+	Polycode.Mesh_addNormal(this.__ptr, nx,ny,nz)
+}
+
+Mesh.prototype.addBoneAssignments = function(b1Weight,b1Index,b2Weight,b2Index,b3Weight,b3Index,b4Weight,b4Index) {
+	Polycode.Mesh_addBoneAssignments(this.__ptr, b1Weight,b1Index,b2Weight,b2Index,b3Weight,b3Index,b4Weight,b4Index)
+}
+
+Mesh.prototype.addColor = function(r,g,b,a) {
+	Polycode.Mesh_addColor(this.__ptr, r,g,b,a)
+}
+
+Mesh.prototype.getVertexPosition = function(vertexOffset) {
+	Polycode.Mesh_getVertexPosition(this.__ptr, vertexOffset)
+}
+
+Mesh.prototype.getVertexPositionAtIndex = function(index) {
+	Polycode.Mesh_getVertexPositionAtIndex(this.__ptr, index)
+}
+
+Mesh.prototype.getVertexTexCoord = function(vertexOffset) {
+	Polycode.Mesh_getVertexTexCoord(this.__ptr, vertexOffset)
+}
+
+Mesh.prototype.getVertexTexCoordAtIndex = function(index) {
+	Polycode.Mesh_getVertexTexCoordAtIndex(this.__ptr, index)
+}
+
+Mesh.prototype.Copy = function() {
+	Polycode.Mesh_Copy(this.__ptr)
+}
+
+Mesh.prototype.getRadius = function() {
+	Polycode.Mesh_getRadius(this.__ptr)
+}
+
+Mesh.prototype.calculateNormals = function() {
+	Polycode.Mesh_calculateNormals(this.__ptr)
+}
+
+Mesh.prototype.calculateTangents = function() {
+	Polycode.Mesh_calculateTangents(this.__ptr)
+}
+
+Mesh.prototype.getMeshType = function() {
+	Polycode.Mesh_getMeshType(this.__ptr)
+}
+
+Mesh.prototype.setMeshType = function(newType) {
+	Polycode.Mesh_setMeshType(this.__ptr, newType)
+}
+
+Mesh.prototype.getIndexGroupSize = function() {
+	Polycode.Mesh_getIndexGroupSize(this.__ptr)
+}
+
+Mesh.prototype.calculateBBox = function() {
+	Polycode.Mesh_calculateBBox(this.__ptr)
+}
+
+Mesh.prototype.hasVertexBuffer = function() {
+	Polycode.Mesh_hasVertexBuffer(this.__ptr)
+}
+
+Mesh.prototype.addIndexedFace = function(i1,i2) {
+	Polycode.Mesh_addIndexedFace(this.__ptr, i1,i2)
+}
+
+Mesh.prototype.addIndex = function(index) {
+	Polycode.Mesh_addIndex(this.__ptr, index)
+}
+
+Mesh.prototype.removeVertexRange = function(beginRemoveVertex,vertexRemovalCount) {
+	Polycode.Mesh_removeVertexRange(this.__ptr, beginRemoveVertex,vertexRemovalCount)
+}
+
+Mesh.prototype.removeFace = function(faceIndex) {
+	Polycode.Mesh_removeFace(this.__ptr, faceIndex)
+}
+
+Mesh.prototype.removeUnusedVertices = function() {
+	Polycode.Mesh_removeUnusedVertices(this.__ptr)
+}
+
+Mesh.prototype.getIndexCount = function() {
+	Polycode.Mesh_getIndexCount(this.__ptr)
+}
+
+Mesh.prototype.subdivideToRadius = function(radius,subdivisions) {
+	Polycode.Mesh_subdivideToRadius(this.__ptr, radius,subdivisions)
+}
+
+Mesh.prototype.saveAsOBJ = function(fileName) {
+	Polycode.Mesh_saveAsOBJ(this.__ptr, fileName)
+}
+
+Mesh.prototype.normalizeBoneWeights = function() {
+	Polycode.Mesh_normalizeBoneWeights(this.__ptr)
+}

bindings/javascript/Polycode/MeshResourceLoader.js

@@ -0,0 +1,6 @@
+function MeshResourceLoader() {
+}
+
+MeshResourceLoader.prototype.loadResource = function(path,targetPool) {
+	Polycode.MeshResourceLoader_loadResource(this.__ptr, path,targetPool)
+}

bindings/javascript/Polycode/MouseEventResult.js

@@ -0,0 +1,2 @@
+function MouseEventResult() {
+}

bindings/javascript/Polycode/OSFileEntry.js

@@ -0,0 +1,6 @@
+function OSFileEntry() {
+}
+
+OSFileEntry.prototype.init = function(path,name,type) {
+	Polycode.OSFileEntry_init(this.__ptr, path,name,type)
+}

bindings/javascript/Polycode/ObjectEntry.js

@@ -0,0 +1,30 @@
+function ObjectEntry() {
+}
+
+ObjectEntry.prototype.readNumber = function(key,out) {
+	Polycode.ObjectEntry_readNumber(this.__ptr, key,out)
+}
+
+ObjectEntry.prototype.readString = function(key,out) {
+	Polycode.ObjectEntry_readString(this.__ptr, key,out)
+}
+
+ObjectEntry.prototype.readBool = function(key,out) {
+	Polycode.ObjectEntry_readBool(this.__ptr, key,out)
+}
+
+ObjectEntry.prototype.addChild = function(name) {
+	Polycode.ObjectEntry_addChild(this.__ptr, name)
+}
+
+ObjectEntry.prototype.getTypedName = function() {
+	Polycode.ObjectEntry_getTypedName(this.__ptr)
+}
+
+ObjectEntry.prototype.setTypedName = function(str) {
+	Polycode.ObjectEntry_setTypedName(this.__ptr, str)
+}
+
+ObjectEntry.prototype.Clear = function() {
+	Polycode.ObjectEntry_Clear(this.__ptr)
+}

bindings/javascript/Polycode/OpenGLGraphicsInterface.js

@@ -0,0 +1,134 @@
+function OpenGLGraphicsInterface() {
+}
+
+OpenGLGraphicsInterface.prototype.createTexture = function(texture) {
+	Polycode.OpenGLGraphicsInterface_createTexture(this.__ptr, texture)
+}
+
+OpenGLGraphicsInterface.prototype.destroyTexture = function(texture) {
+	Polycode.OpenGLGraphicsInterface_destroyTexture(this.__ptr, texture)
+}
+
+OpenGLGraphicsInterface.prototype.setViewport = function(x,y,width,height) {
+	Polycode.OpenGLGraphicsInterface_setViewport(this.__ptr, x,y,width,height)
+}
+
+OpenGLGraphicsInterface.prototype.clearBuffers = function(clearColor,colorBuffer,depthBuffer,stencilBuffer) {
+	Polycode.OpenGLGraphicsInterface_clearBuffers(this.__ptr, clearColor,colorBuffer,depthBuffer,stencilBuffer)
+}
+
+OpenGLGraphicsInterface.prototype.setParamInShader = function(shader,param,localParam) {
+	Polycode.OpenGLGraphicsInterface_setParamInShader(this.__ptr, shader,param,localParam)
+}
+
+OpenGLGraphicsInterface.prototype.setAttributeInShader = function(shader,attribute,attributeBinding) {
+	Polycode.OpenGLGraphicsInterface_setAttributeInShader(this.__ptr, shader,attribute,attributeBinding)
+}
+
+OpenGLGraphicsInterface.prototype.disableAttribute = function(shader,attribute) {
+	Polycode.OpenGLGraphicsInterface_disableAttribute(this.__ptr, shader,attribute)
+}
+
+OpenGLGraphicsInterface.prototype.useShader = function(shader) {
+	Polycode.OpenGLGraphicsInterface_useShader(this.__ptr, shader)
+}
+
+OpenGLGraphicsInterface.prototype.createProgram = function(program) {
+	Polycode.OpenGLGraphicsInterface_createProgram(this.__ptr, program)
+}
+
+OpenGLGraphicsInterface.prototype.destroyProgram = function(program) {
+	Polycode.OpenGLGraphicsInterface_destroyProgram(this.__ptr, program)
+}
+
+OpenGLGraphicsInterface.prototype.createVBOForVertexArray = function(array) {
+	Polycode.OpenGLGraphicsInterface_createVBOForVertexArray(this.__ptr, array)
+}
+
+OpenGLGraphicsInterface.prototype.createMesh = function(mesh) {
+	Polycode.OpenGLGraphicsInterface_createMesh(this.__ptr, mesh)
+}
+
+OpenGLGraphicsInterface.prototype.destroyMesh = function(mesh) {
+	Polycode.OpenGLGraphicsInterface_destroyMesh(this.__ptr, mesh)
+}
+
+OpenGLGraphicsInterface.prototype.createShader = function(shader) {
+	Polycode.OpenGLGraphicsInterface_createShader(this.__ptr, shader)
+}
+
+OpenGLGraphicsInterface.prototype.destroyShader = function(shader) {
+	Polycode.OpenGLGraphicsInterface_destroyShader(this.__ptr, shader)
+}
+
+OpenGLGraphicsInterface.prototype.beginDrawCall = function() {
+	Polycode.OpenGLGraphicsInterface_beginDrawCall(this.__ptr)
+}
+
+OpenGLGraphicsInterface.prototype.endDrawCall = function() {
+	Polycode.OpenGLGraphicsInterface_endDrawCall(this.__ptr)
+}
+
+OpenGLGraphicsInterface.prototype.setBlendingMode = function(blendingMode) {
+	Polycode.OpenGLGraphicsInterface_setBlendingMode(this.__ptr, blendingMode)
+}
+
+OpenGLGraphicsInterface.prototype.createRenderBuffer = function(renderBuffer) {
+	Polycode.OpenGLGraphicsInterface_createRenderBuffer(this.__ptr, renderBuffer)
+}
+
+OpenGLGraphicsInterface.prototype.destroyRenderBuffer = function(renderBuffer) {
+	Polycode.OpenGLGraphicsInterface_destroyRenderBuffer(this.__ptr, renderBuffer)
+}
+
+OpenGLGraphicsInterface.prototype.bindRenderBuffer = function(renderBuffer) {
+	Polycode.OpenGLGraphicsInterface_bindRenderBuffer(this.__ptr, renderBuffer)
+}
+
+OpenGLGraphicsInterface.prototype.createVertexBuffer = function(dataArray) {
+	Polycode.OpenGLGraphicsInterface_createVertexBuffer(this.__ptr, dataArray)
+}
+
+OpenGLGraphicsInterface.prototype.createIndexBuffer = function(dataArray) {
+	Polycode.OpenGLGraphicsInterface_createIndexBuffer(this.__ptr, dataArray)
+}
+
+OpenGLGraphicsInterface.prototype.destroyBuffer = function(array) {
+	Polycode.OpenGLGraphicsInterface_destroyBuffer(this.__ptr, array)
+}
+
+OpenGLGraphicsInterface.prototype.drawIndices = function(type,indexArray) {
+	Polycode.OpenGLGraphicsInterface_drawIndices(this.__ptr, type,indexArray)
+}
+
+OpenGLGraphicsInterface.prototype.drawArrays = function(type,vertexCount) {
+	Polycode.OpenGLGraphicsInterface_drawArrays(this.__ptr, type,vertexCount)
+}
+
+OpenGLGraphicsInterface.prototype.enableDepthTest = function(val) {
+	Polycode.OpenGLGraphicsInterface_enableDepthTest(this.__ptr, val)
+}
+
+OpenGLGraphicsInterface.prototype.enableDepthWrite = function(val) {
+	Polycode.OpenGLGraphicsInterface_enableDepthWrite(this.__ptr, val)
+}
+
+OpenGLGraphicsInterface.prototype.enableBackfaceCulling = function(val) {
+	Polycode.OpenGLGraphicsInterface_enableBackfaceCulling(this.__ptr, val)
+}
+
+OpenGLGraphicsInterface.prototype.setLineSize = function(lineSize) {
+	Polycode.OpenGLGraphicsInterface_setLineSize(this.__ptr, lineSize)
+}
+
+OpenGLGraphicsInterface.prototype.setWireframeMode = function(val) {
+	Polycode.OpenGLGraphicsInterface_setWireframeMode(this.__ptr, val)
+}
+
+OpenGLGraphicsInterface.prototype.enableScissor = function(val) {
+	Polycode.OpenGLGraphicsInterface_enableScissor(this.__ptr, val)
+}
+
+OpenGLGraphicsInterface.prototype.setScissorBox = function(box) {
+	Polycode.OpenGLGraphicsInterface_setScissorBox(this.__ptr, box)
+}

bindings/javascript/Polycode/Perlin.js

@@ -0,0 +1,18 @@
+function Perlin() {
+}
+
+Perlin.prototype.Get2DTiledX = function(x,y,t) {
+	Polycode.Perlin_Get2DTiledX(this.__ptr, x,y,t)
+}
+
+Perlin.prototype.Get = function(x,y) {
+	Polycode.Perlin_Get(this.__ptr, x,y)
+}
+
+Perlin.prototype.Get2D = function(x,y) {
+	Polycode.Perlin_Get2D(this.__ptr, x,y)
+}
+
+Perlin.prototype.Get3D = function(x,y,z) {
+	Polycode.Perlin_Get3D(this.__ptr, x,y,z)
+}

bindings/javascript/Polycode/PhysFSFile.js

@@ -0,0 +1,18 @@
+function PhysFSFile() {
+}
+
+PhysFSFile.prototype.read = function(ptr,size,count) {
+	Polycode.PhysFSFile_read(this.__ptr, ptr,size,count)
+}
+
+PhysFSFile.prototype.write = function(ptr,size,count) {
+	Polycode.PhysFSFile_write(this.__ptr, ptr,size,count)
+}
+
+PhysFSFile.prototype.seek = function(offset,origin) {
+	Polycode.PhysFSFile_seek(this.__ptr, offset,origin)
+}
+
+PhysFSFile.prototype.tell = function() {
+	Polycode.PhysFSFile_tell(this.__ptr)
+}

bindings/javascript/Polycode/PhysFSFileProvider.js

@@ -0,0 +1,22 @@
+function PhysFSFileProvider() {
+}
+
+PhysFSFileProvider.prototype.openFile = function(fileName,opts) {
+	Polycode.PhysFSFileProvider_openFile(this.__ptr, fileName,opts)
+}
+
+PhysFSFileProvider.prototype.closeFile = function(file) {
+	Polycode.PhysFSFileProvider_closeFile(this.__ptr, file)
+}
+
+PhysFSFileProvider.prototype.parseFolder = function(pathString,showHidden,targetVector) {
+	Polycode.PhysFSFileProvider_parseFolder(this.__ptr, pathString,showHidden,targetVector)
+}
+
+PhysFSFileProvider.prototype.addSource = function(source) {
+	Polycode.PhysFSFileProvider_addSource(this.__ptr, source)
+}
+
+PhysFSFileProvider.prototype.removeSource = function(source) {
+	Polycode.PhysFSFileProvider_removeSource(this.__ptr, source)
+}

bindings/javascript/Polycode/PolycodeViewBase.js

@@ -0,0 +1,2 @@
+function PolycodeViewBase() {
+}

bindings/javascript/Polycode/ProgramAttribute.js

@@ -0,0 +1,2 @@
+function ProgramAttribute() {
+}

bindings/javascript/Polycode/ProgramParam.js

@@ -0,0 +1,2 @@
+function ProgramParam() {
+}

bindings/javascript/Polycode/ProgramResourceLoader.js

@@ -0,0 +1,6 @@
+function ProgramResourceLoader() {
+}
+
+ProgramResourceLoader.prototype.loadResource = function(path,targetPool) {
+	Polycode.ProgramResourceLoader_loadResource(this.__ptr, path,targetPool)
+}

bindings/javascript/Polycode/QuatTriple.js

@@ -0,0 +1,2 @@
+function QuatTriple() {
+}

bindings/javascript/Polycode/Quaternion.js

@@ -0,0 +1,74 @@
+function Quaternion() {
+}
+
+Quaternion.prototype.setFromMatrix = function(_mat) {
+	Polycode.Quaternion_setFromMatrix(this.__ptr, _mat)
+}
+
+Quaternion.prototype.Dot = function(rkQ) {
+	Polycode.Quaternion_Dot(this.__ptr, rkQ)
+}
+
+Quaternion.prototype.Log = function() {
+	Polycode.Quaternion_Log(this.__ptr)
+}
+
+Quaternion.prototype.Exp = function() {
+	Polycode.Quaternion_Exp(this.__ptr)
+}
+
+Quaternion.prototype.Norm = function() {
+	Polycode.Quaternion_Norm(this.__ptr)
+}
+
+Quaternion.prototype.Normalize = function() {
+	Polycode.Quaternion_Normalize(this.__ptr)
+}
+
+Quaternion.prototype.lookAt = function(D,upVector) {
+	Polycode.Quaternion_lookAt(this.__ptr, D,upVector)
+}
+
+Quaternion.prototype.createFromMatrix = function(matrix) {
+	Polycode.Quaternion_createFromMatrix(this.__ptr, matrix)
+}
+
+Quaternion.prototype.Inverse = function() {
+	Polycode.Quaternion_Inverse(this.__ptr)
+}
+
+Quaternion.prototype.set = function(w,x,y,z) {
+	Polycode.Quaternion_set(this.__ptr, w,x,y,z)
+}
+
+Quaternion.prototype.InvSqrt = function(x) {
+	Polycode.Quaternion_InvSqrt(this.__ptr, x)
+}
+
+Quaternion.prototype.fromAxes = function(az,ay,ax) {
+	Polycode.Quaternion_fromAxes(this.__ptr, az,ay,ax)
+}
+
+Quaternion.prototype.fromAngleAxis = function(rfAngle,rkAxis) {
+	Polycode.Quaternion_fromAngleAxis(this.__ptr, rfAngle,rkAxis)
+}
+
+Quaternion.prototype.toEulerAngles = function() {
+	Polycode.Quaternion_toEulerAngles(this.__ptr)
+}
+
+Quaternion.prototype.toAngleAxis = function(rfAngle,rkAxis) {
+	Polycode.Quaternion_toAngleAxis(this.__ptr, rfAngle,rkAxis)
+}
+
+Quaternion.prototype.createFromAxisAngle = function(x,y,z,degrees) {
+	Polycode.Quaternion_createFromAxisAngle(this.__ptr, x,y,z,degrees)
+}
+
+Quaternion.prototype.createMatrix = function() {
+	Polycode.Quaternion_createMatrix(this.__ptr)
+}
+
+Quaternion.prototype.applyTo = function(v) {
+	Polycode.Quaternion_applyTo(this.__ptr, v)
+}

bindings/javascript/Polycode/QuaternionCurve.js

@@ -0,0 +1,10 @@
+function QuaternionCurve() {
+}
+
+QuaternionCurve.prototype.interpolate = function(t,useShortestPath) {
+	Polycode.QuaternionCurve_interpolate(this.__ptr, t,useShortestPath)
+}
+
+QuaternionCurve.prototype.generatePointsFromCurves = function(wCurve,xCurve,yCurve,zCurve) {
+	Polycode.QuaternionCurve_generatePointsFromCurves(this.__ptr, wCurve,xCurve,yCurve,zCurve)
+}

bindings/javascript/Polycode/Ray.js

@@ -0,0 +1,26 @@
+function Ray() {
+}
+
+Ray.prototype.boxIntersect = function(box,transformMatrix,near,far) {
+	Polycode.Ray_boxIntersect(this.__ptr, box,transformMatrix,near,far)
+}
+
+Ray.prototype.planeIntersectPoint = function(planeNormal,planeDistance) {
+	Polycode.Ray_planeIntersectPoint(this.__ptr, planeNormal,planeDistance)
+}
+
+Ray.prototype.tranformByMatrix = function(matrix) {
+	Polycode.Ray_tranformByMatrix(this.__ptr, matrix)
+}
+
+Ray.prototype.closestPointOnRay = function(point) {
+	Polycode.Ray_closestPointOnRay(this.__ptr, point)
+}
+
+Ray.prototype.closestPointsBetween = function(ray2,point1,point2) {
+	Polycode.Ray_closestPointsBetween(this.__ptr, ray2,point1,point2)
+}
+
+Ray.prototype.polygonIntersect = function(v1,v2,v3) {
+	Polycode.Ray_polygonIntersect(this.__ptr, v1,v2,v3)
+}

bindings/javascript/Polycode/Rectangle.js

@@ -0,0 +1,26 @@
+function Rectangle() {
+}
+
+Rectangle.prototype.setRect = function(x,y,w,h) {
+	Polycode.Rectangle_setRect(this.__ptr, x,y,w,h)
+}
+
+Rectangle.prototype.Clipped = function(rect) {
+	Polycode.Rectangle_Clipped(this.__ptr, rect)
+}
+
+Rectangle.prototype.minX = function() {
+	Polycode.Rectangle_minX(this.__ptr)
+}
+
+Rectangle.prototype.maxX = function() {
+	Polycode.Rectangle_maxX(this.__ptr)
+}
+
+Rectangle.prototype.minY = function() {
+	Polycode.Rectangle_minY(this.__ptr)
+}
+
+Rectangle.prototype.maxY = function() {
+	Polycode.Rectangle_maxY(this.__ptr)
+}

bindings/javascript/Polycode/RenderBuffer.js

@@ -0,0 +1,10 @@
+function RenderBuffer() {
+}
+
+RenderBuffer.prototype.getWidth = function() {
+	Polycode.RenderBuffer_getWidth(this.__ptr)
+}
+
+RenderBuffer.prototype.getHeight = function() {
+	Polycode.RenderBuffer_getHeight(this.__ptr)
+}

bindings/javascript/Polycode/RenderDataArray.js

@@ -0,0 +1,10 @@
+function RenderDataArray() {
+}
+
+RenderDataArray.prototype.getArrayData = function() {
+	Polycode.RenderDataArray_getArrayData(this.__ptr)
+}
+
+RenderDataArray.prototype.getDataSize = function() {
+	Polycode.RenderDataArray_getDataSize(this.__ptr)
+}

bindings/javascript/Polycode/RenderFrame.js

@@ -0,0 +1,2 @@
+function RenderFrame() {
+}

bindings/javascript/Polycode/RenderTargetBinding.js

@@ -0,0 +1,2 @@
+function RenderTargetBinding() {
+}

bindings/javascript/Polycode/RenderThread.js

@@ -0,0 +1,50 @@
+function RenderThread() {
+}
+
+RenderThread.prototype.setGraphicsInterface = function(core,graphicsInterface) {
+	Polycode.RenderThread_setGraphicsInterface(this.__ptr, core,graphicsInterface)
+}
+
+RenderThread.prototype.runThread = function() {
+	Polycode.RenderThread_runThread(this.__ptr)
+}
+
+RenderThread.prototype.enqueueFrame = function(frame) {
+	Polycode.RenderThread_enqueueFrame(this.__ptr, frame)
+}
+
+RenderThread.prototype.enqueueJob = function(jobType,data,data2) {
+	Polycode.RenderThread_enqueueJob(this.__ptr, jobType,data,data2)
+}
+
+RenderThread.prototype.processJob = function(job) {
+	Polycode.RenderThread_processJob(this.__ptr, job)
+}
+
+RenderThread.prototype.getShaderBinding = function() {
+	Polycode.RenderThread_getShaderBinding(this.__ptr)
+}
+
+RenderThread.prototype.processDrawBuffer = function(buffer) {
+	Polycode.RenderThread_processDrawBuffer(this.__ptr, buffer)
+}
+
+RenderThread.prototype.getFrameInfo = function() {
+	Polycode.RenderThread_getFrameInfo(this.__ptr)
+}
+
+RenderThread.prototype.clearFrameQueue = function() {
+	Polycode.RenderThread_clearFrameQueue(this.__ptr)
+}
+
+RenderThread.prototype.initGlobals = function() {
+	Polycode.RenderThread_initGlobals(this.__ptr)
+}
+
+RenderThread.prototype.lockRenderMutex = function() {
+	Polycode.RenderThread_lockRenderMutex(this.__ptr)
+}
+
+RenderThread.prototype.unlockRenderMutex = function() {
+	Polycode.RenderThread_unlockRenderMutex(this.__ptr)
+}

bindings/javascript/Polycode/RenderThreadDebugInfo.js

@@ -0,0 +1,2 @@
+function RenderThreadDebugInfo() {
+}

bindings/javascript/Polycode/Renderer.js

@@ -0,0 +1,110 @@
+function Renderer() {
+}
+
+Renderer.prototype.setGraphicsInterface = function(core,graphicsInterface) {
+	Polycode.Renderer_setGraphicsInterface(this.__ptr, core,graphicsInterface)
+}
+
+Renderer.prototype.getRenderThread = function() {
+	Polycode.Renderer_getRenderThread(this.__ptr)
+}
+
+Renderer.prototype.createCubemap = function(t0,t1,t2,t3,t4,t5) {
+	Polycode.Renderer_createCubemap(this.__ptr, t0,t1,t2,t3,t4,t5)
+}
+
+Renderer.prototype.createTexture = function(width,height,textureData,clamp,createMipmaps,type,filteringMode,anisotropy,framebufferTexture) {
+	Polycode.Renderer_createTexture(this.__ptr, width,height,textureData,clamp,createMipmaps,type,filteringMode,anisotropy,framebufferTexture)
+}
+
+Renderer.prototype.createRenderBuffer = function(width,height,attachDepthBuffer,floatingPoint) {
+	Polycode.Renderer_createRenderBuffer(this.__ptr, width,height,attachDepthBuffer,floatingPoint)
+}
+
+Renderer.prototype.destroyRenderBuffer = function(buffer) {
+	Polycode.Renderer_destroyRenderBuffer(this.__ptr, buffer)
+}
+
+Renderer.prototype.destroyTexture = function(texture) {
+	Polycode.Renderer_destroyTexture(this.__ptr, texture)
+}
+
+Renderer.prototype.processDrawBuffer = function(buffer) {
+	Polycode.Renderer_processDrawBuffer(this.__ptr, buffer)
+}
+
+Renderer.prototype.setBackingResolutionScale = function(xScale,yScale) {
+	Polycode.Renderer_setBackingResolutionScale(this.__ptr, xScale,yScale)
+}
+
+Renderer.prototype.getBackingResolutionScaleX = function() {
+	Polycode.Renderer_getBackingResolutionScaleX(this.__ptr)
+}
+
+Renderer.prototype.getBackingResolutionScaleY = function() {
+	Polycode.Renderer_getBackingResolutionScaleY(this.__ptr)
+}
+
+Renderer.prototype.createProgram = function(fileName) {
+	Polycode.Renderer_createProgram(this.__ptr, fileName)
+}
+
+Renderer.prototype.createShader = function(vertexProgram,fragmentProgram) {
+	Polycode.Renderer_createShader(this.__ptr, vertexProgram,fragmentProgram)
+}
+
+Renderer.prototype.createVertexBuffers = function(mesh) {
+	Polycode.Renderer_createVertexBuffers(this.__ptr, mesh)
+}
+
+Renderer.prototype.enqueueFrameJob = function(jobType,data) {
+	Polycode.Renderer_enqueueFrameJob(this.__ptr, jobType,data)
+}
+
+Renderer.prototype.destroyProgram = function(program) {
+	Polycode.Renderer_destroyProgram(this.__ptr, program)
+}
+
+Renderer.prototype.destroyShader = function(shader) {
+	Polycode.Renderer_destroyShader(this.__ptr, shader)
+}
+
+Renderer.prototype.destroyBuffer = function(array) {
+	Polycode.Renderer_destroyBuffer(this.__ptr, array)
+}
+
+Renderer.prototype.destroyShaderBinding = function(binding) {
+	Polycode.Renderer_destroyShaderBinding(this.__ptr, binding)
+}
+
+Renderer.prototype.destroyShaderParam = function(param) {
+	Polycode.Renderer_destroyShaderParam(this.__ptr, param)
+}
+
+Renderer.prototype.setTextureParam = function(param,texture) {
+	Polycode.Renderer_setTextureParam(this.__ptr, param,texture)
+}
+
+Renderer.prototype.setAnisotropyAmount = function(amount) {
+	Polycode.Renderer_setAnisotropyAmount(this.__ptr, amount)
+}
+
+Renderer.prototype.getAnisotropyAmount = function() {
+	Polycode.Renderer_getAnisotropyAmount(this.__ptr)
+}
+
+Renderer.prototype.createMesh = function(fileName) {
+	Polycode.Renderer_createMesh(this.__ptr, fileName)
+}
+
+Renderer.prototype.destroyMesh = function(mesh) {
+	Polycode.Renderer_destroyMesh(this.__ptr, mesh)
+}
+
+Renderer.prototype.beginFrame = function() {
+	Polycode.Renderer_beginFrame(this.__ptr)
+}
+
+Renderer.prototype.endFrame = function() {
+	Polycode.Renderer_endFrame(this.__ptr)
+}

bindings/javascript/Polycode/RendererThreadJob.js

@@ -0,0 +1,2 @@
+function RendererThreadJob() {
+}

bindings/javascript/Polycode/Resource.js

@@ -0,0 +1,26 @@
+function Resource() {
+}
+
+Resource.prototype.reloadResource = function() {
+	Polycode.Resource_reloadResource(this.__ptr)
+}
+
+Resource.prototype.getResourceName = function() {
+	Polycode.Resource_getResourceName(this.__ptr)
+}
+
+Resource.prototype.getResourceType = function() {
+	Polycode.Resource_getResourceType(this.__ptr)
+}
+
+Resource.prototype.setResourceName = function(newName) {
+	Polycode.Resource_setResourceName(this.__ptr, newName)
+}
+
+Resource.prototype.setResourcePath = function(path) {
+	Polycode.Resource_setResourcePath(this.__ptr, path)
+}
+
+Resource.prototype.getResourcePath = function() {
+	Polycode.Resource_getResourcePath(this.__ptr)
+}

bindings/javascript/Polycode/ResourceManager.js

@@ -0,0 +1,58 @@
+function ResourceManager() {
+}
+
+ResourceManager.prototype.getGlobalPool = function() {
+	Polycode.ResourceManager_getGlobalPool(this.__ptr)
+}
+
+ResourceManager.prototype.getResourcePoolByName = function(name) {
+	Polycode.ResourceManager_getResourcePoolByName(this.__ptr, name)
+}
+
+ResourceManager.prototype.addResourceLoader = function(loader) {
+	Polycode.ResourceManager_addResourceLoader(this.__ptr, loader)
+}
+
+ResourceManager.prototype.getResourceLoaderForExtension = function(extension) {
+	Polycode.ResourceManager_getResourceLoaderForExtension(this.__ptr, extension)
+}
+
+ResourceManager.prototype.removeResourceLoader = function(loader) {
+	Polycode.ResourceManager_removeResourceLoader(this.__ptr, loader)
+}
+
+ResourceManager.prototype.getNumResourceLoaders = function() {
+	Polycode.ResourceManager_getNumResourceLoaders(this.__ptr)
+}
+
+ResourceManager.prototype.getResourceLoaderAtIndex = function(index) {
+	Polycode.ResourceManager_getResourceLoaderAtIndex(this.__ptr, index)
+}
+
+ResourceManager.prototype.addResourcePool = function(pool) {
+	Polycode.ResourceManager_addResourcePool(this.__ptr, pool)
+}
+
+ResourceManager.prototype.removeResourcePool = function(pool) {
+	Polycode.ResourceManager_removeResourcePool(this.__ptr, pool)
+}
+
+ResourceManager.prototype.getResources = function(resourceType) {
+	Polycode.ResourceManager_getResources(this.__ptr, resourceType)
+}
+
+ResourceManager.prototype.removeResource = function(resource) {
+	Polycode.ResourceManager_removeResource(this.__ptr, resource)
+}
+
+ResourceManager.prototype.subscribeToResourcePool = function(pool) {
+	Polycode.ResourceManager_subscribeToResourcePool(this.__ptr, pool)
+}
+
+ResourceManager.prototype.unsubscibeFromResourcePool = function(pool) {
+	Polycode.ResourceManager_unsubscibeFromResourcePool(this.__ptr, pool)
+}
+
+ResourceManager.prototype.Update = function(elapsed) {
+	Polycode.ResourceManager_Update(this.__ptr, elapsed)
+}

bindings/javascript/Polycode/ResourcePool.js

@@ -0,0 +1,58 @@
+function ResourcePool() {
+}
+
+ResourcePool.prototype.setFallbackPool = function(pool) {
+	Polycode.ResourcePool_setFallbackPool(this.__ptr, pool)
+}
+
+ResourcePool.prototype.addResource = function(resource) {
+	Polycode.ResourcePool_addResource(this.__ptr, resource)
+}
+
+ResourcePool.prototype.removeResource = function(resource) {
+	Polycode.ResourcePool_removeResource(this.__ptr, resource)
+}
+
+ResourcePool.prototype.hasResource = function(resource) {
+	Polycode.ResourcePool_hasResource(this.__ptr, resource)
+}
+
+ResourcePool.prototype.loadResourcesFromFolder = function(folder,recursive) {
+	Polycode.ResourcePool_loadResourcesFromFolder(this.__ptr, folder,recursive)
+}
+
+ResourcePool.prototype.loadResource = function(path) {
+	Polycode.ResourcePool_loadResource(this.__ptr, path)
+}
+
+ResourcePool.prototype.loadResourceWithName = function(path,name) {
+	Polycode.ResourcePool_loadResourceWithName(this.__ptr, path,name)
+}
+
+ResourcePool.prototype.getResource = function(resourceType,resourceName) {
+	Polycode.ResourcePool_getResource(this.__ptr, resourceType,resourceName)
+}
+
+ResourcePool.prototype.getName = function() {
+	Polycode.ResourcePool_getName(this.__ptr)
+}
+
+ResourcePool.prototype.setName = function(name) {
+	Polycode.ResourcePool_setName(this.__ptr, name)
+}
+
+ResourcePool.prototype.getResourceByPath = function(resourcePath) {
+	Polycode.ResourcePool_getResourceByPath(this.__ptr, resourcePath)
+}
+
+ResourcePool.prototype.Update = function(elapsed) {
+	Polycode.ResourcePool_Update(this.__ptr, elapsed)
+}
+
+ResourcePool.prototype.getResources = function(resourceType) {
+	Polycode.ResourcePool_getResources(this.__ptr, resourceType)
+}
+
+ResourcePool.prototype.checkForChangedFiles = function() {
+	Polycode.ResourcePool_checkForChangedFiles(this.__ptr)
+}

bindings/javascript/Polycode/Rotation.js

@@ -0,0 +1,2 @@
+function Rotation() {
+}

bindings/javascript/Polycode/Scene.js

@@ -0,0 +1,98 @@
+function Scene() {
+}
+
+Scene.prototype.addEntity = function(entity) {
+	Polycode.Scene_addEntity(this.__ptr, entity)
+}
+
+Scene.prototype.addChild = function(entity) {
+	Polycode.Scene_addChild(this.__ptr, entity)
+}
+
+Scene.prototype.removeEntity = function(entity) {
+	Polycode.Scene_removeEntity(this.__ptr, entity)
+}
+
+Scene.prototype.getDefaultCamera = function() {
+	Polycode.Scene_getDefaultCamera(this.__ptr)
+}
+
+Scene.prototype.getActiveCamera = function() {
+	Polycode.Scene_getActiveCamera(this.__ptr)
+}
+
+Scene.prototype.setActiveCamera = function(camera) {
+	Polycode.Scene_setActiveCamera(this.__ptr, camera)
+}
+
+Scene.prototype.enableFog = function(enable) {
+	Polycode.Scene_enableFog(this.__ptr, enable)
+}
+
+Scene.prototype.setFogProperties = function(fogMode,color,density,startDepth,endDepth) {
+	Polycode.Scene_setFogProperties(this.__ptr, fogMode,color,density,startDepth,endDepth)
+}
+
+Scene.prototype.setSceneType = function(newType) {
+	Polycode.Scene_setSceneType(this.__ptr, newType)
+}
+
+Scene.prototype.fixedUpdate = function() {
+	Polycode.Scene_fixedUpdate(this.__ptr)
+}
+
+Scene.prototype.Update = function() {
+	Polycode.Scene_Update(this.__ptr)
+}
+
+Scene.prototype.setVirtual = function(val) {
+	Polycode.Scene_setVirtual(this.__ptr, val)
+}
+
+Scene.prototype.isVirtual = function() {
+	Polycode.Scene_isVirtual(this.__ptr)
+}
+
+Scene.prototype.isEnabled = function() {
+	Polycode.Scene_isEnabled(this.__ptr)
+}
+
+Scene.prototype.setEnabled = function(enabled) {
+	Polycode.Scene_setEnabled(this.__ptr, enabled)
+}
+
+Scene.prototype.Render = function(targetCamera,targetFramebuffer,overrideMaterial,sendLights) {
+	Polycode.Scene_Render(this.__ptr, targetCamera,targetFramebuffer,overrideMaterial,sendLights)
+}
+
+Scene.prototype.setOverrideMaterial = function(material) {
+	Polycode.Scene_setOverrideMaterial(this.__ptr, material)
+}
+
+Scene.prototype.projectRayFromCameraAndViewportCoordinate = function(camera,coordinate) {
+	Polycode.Scene_projectRayFromCameraAndViewportCoordinate(this.__ptr, camera,coordinate)
+}
+
+Scene.prototype.addLight = function(light) {
+	Polycode.Scene_addLight(this.__ptr, light)
+}
+
+Scene.prototype.removeLight = function(light) {
+	Polycode.Scene_removeLight(this.__ptr, light)
+}
+
+Scene.prototype.getNumLights = function() {
+	Polycode.Scene_getNumLights(this.__ptr)
+}
+
+Scene.prototype.getLight = function(index) {
+	Polycode.Scene_getLight(this.__ptr, index)
+}
+
+Scene.prototype.doVisibilityChecking = function(val) {
+	Polycode.Scene_doVisibilityChecking(this.__ptr, val)
+}
+
+Scene.prototype.doesVisibilityChecking = function() {
+	Polycode.Scene_doesVisibilityChecking(this.__ptr)
+}

bindings/javascript/Polycode/SceneCurve.js

@@ -0,0 +1,22 @@
+function SceneCurve() {
+}
+
+SceneCurve.prototype.getWorldPointAt = function(t) {
+	Polycode.SceneCurve_getWorldPointAt(this.__ptr, t)
+}
+
+SceneCurve.prototype.Update = function() {
+	Polycode.SceneCurve_Update(this.__ptr)
+}
+
+SceneCurve.prototype.Clone = function(deepClone,ignoreEditorOnly) {
+	Polycode.SceneCurve_Clone(this.__ptr, deepClone,ignoreEditorOnly)
+}
+
+SceneCurve.prototype.applyClone = function(clone,deepClone,ignoreEditorOnly) {
+	Polycode.SceneCurve_applyClone(this.__ptr, clone,deepClone,ignoreEditorOnly)
+}
+
+SceneCurve.prototype.getCurve = function() {
+	Polycode.SceneCurve_getCurve(this.__ptr)
+}

bindings/javascript/Polycode/SceneEntityInstance.js

@@ -0,0 +1,82 @@
+function SceneEntityInstance() {
+}
+
+SceneEntityInstance.prototype.Clone = function(deepClone,ignoreEditorOnly) {
+	Polycode.SceneEntityInstance_Clone(this.__ptr, deepClone,ignoreEditorOnly)
+}
+
+SceneEntityInstance.prototype.applyClone = function(clone,deepClone,ignoreEditorOnly) {
+	Polycode.SceneEntityInstance_applyClone(this.__ptr, clone,deepClone,ignoreEditorOnly)
+}
+
+SceneEntityInstance.prototype.reloadEntityInstance = function() {
+	Polycode.SceneEntityInstance_reloadEntityInstance(this.__ptr)
+}
+
+SceneEntityInstance.prototype.clearInstance = function() {
+	Polycode.SceneEntityInstance_clearInstance(this.__ptr)
+}
+
+SceneEntityInstance.prototype.parseObjectIntoCurve = function(entry,curve) {
+	Polycode.SceneEntityInstance_parseObjectIntoCurve(this.__ptr, entry,curve)
+}
+
+SceneEntityInstance.prototype.loadObjectEntryIntoEntity = function(entry,targetEntity,entityFileVersion) {
+	Polycode.SceneEntityInstance_loadObjectEntryIntoEntity(this.__ptr, entry,targetEntity,entityFileVersion)
+}
+
+SceneEntityInstance.prototype.loadFromFile = function(fileName) {
+	Polycode.SceneEntityInstance_loadFromFile(this.__ptr, fileName)
+}
+
+SceneEntityInstance.prototype.applySceneMesh = function(entry,sceneMesh) {
+	Polycode.SceneEntityInstance_applySceneMesh(this.__ptr, entry,sceneMesh)
+}
+
+SceneEntityInstance.prototype.linkResourcePool = function(pool) {
+	Polycode.SceneEntityInstance_linkResourcePool(this.__ptr, pool)
+}
+
+SceneEntityInstance.prototype.getNumLinkedResourePools = function() {
+	Polycode.SceneEntityInstance_getNumLinkedResourePools(this.__ptr)
+}
+
+SceneEntityInstance.prototype.getLinkedResourcePoolAtIndex = function(index) {
+	Polycode.SceneEntityInstance_getLinkedResourcePoolAtIndex(this.__ptr, index)
+}
+
+SceneEntityInstance.prototype.unlinkResourcePool = function(pool) {
+	Polycode.SceneEntityInstance_unlinkResourcePool(this.__ptr, pool)
+}
+
+SceneEntityInstance.prototype.getResourceEntry = function() {
+	Polycode.SceneEntityInstance_getResourceEntry(this.__ptr)
+}
+
+SceneEntityInstance.prototype.getTopLevelResourcePool = function() {
+	Polycode.SceneEntityInstance_getTopLevelResourcePool(this.__ptr)
+}
+
+SceneEntityInstance.prototype.hasLayerID = function(layerID) {
+	Polycode.SceneEntityInstance_hasLayerID(this.__ptr, layerID)
+}
+
+SceneEntityInstance.prototype.getNumLayers = function() {
+	Polycode.SceneEntityInstance_getNumLayers(this.__ptr)
+}
+
+SceneEntityInstance.prototype.getLayerAtIndex = function(index) {
+	Polycode.SceneEntityInstance_getLayerAtIndex(this.__ptr, index)
+}
+
+SceneEntityInstance.prototype.removeLayer = function(layer) {
+	Polycode.SceneEntityInstance_removeLayer(this.__ptr, layer)
+}
+
+SceneEntityInstance.prototype.createNewLayer = function(name) {
+	Polycode.SceneEntityInstance_createNewLayer(this.__ptr, name)
+}
+
+SceneEntityInstance.prototype.getFileName = function() {
+	Polycode.SceneEntityInstance_getFileName(this.__ptr)
+}

bindings/javascript/Polycode/SceneEntityInstanceLayer.js

@@ -0,0 +1,6 @@
+function SceneEntityInstanceLayer() {
+}
+
+SceneEntityInstanceLayer.prototype.setLayerVisibility = function(val) {
+	Polycode.SceneEntityInstanceLayer_setLayerVisibility(this.__ptr, val)
+}

bindings/javascript/Polycode/SceneEntityInstanceResourceEntry.js

@@ -0,0 +1,10 @@
+function SceneEntityInstanceResourceEntry() {
+}
+
+SceneEntityInstanceResourceEntry.prototype.getInstance = function() {
+	Polycode.SceneEntityInstanceResourceEntry_getInstance(this.__ptr)
+}
+
+SceneEntityInstanceResourceEntry.prototype.reloadResource = function() {
+	Polycode.SceneEntityInstanceResourceEntry_reloadResource(this.__ptr)
+}

bindings/javascript/Polycode/SceneImage.js

@@ -0,0 +1,22 @@
+function SceneImage() {
+}
+
+SceneImage.prototype.Clone = function(deepClone,ignoreEditorOnly) {
+	Polycode.SceneImage_Clone(this.__ptr, deepClone,ignoreEditorOnly)
+}
+
+SceneImage.prototype.applyClone = function(clone,deepClone,ignoreEditorOnly) {
+	Polycode.SceneImage_applyClone(this.__ptr, clone,deepClone,ignoreEditorOnly)
+}
+
+SceneImage.prototype.setImageCoordinates = function(x,y,width,height,realWidth,realHeight) {
+	Polycode.SceneImage_setImageCoordinates(this.__ptr, x,y,width,height,realWidth,realHeight)
+}
+
+SceneImage.prototype.getImageWidth = function() {
+	Polycode.SceneImage_getImageWidth(this.__ptr)
+}
+
+SceneImage.prototype.getImageHeight = function() {
+	Polycode.SceneImage_getImageHeight(this.__ptr)
+}

bindings/javascript/Polycode/SceneLabel.js

@@ -0,0 +1,42 @@
+function SceneLabel() {
+}
+
+SceneLabel.prototype.getText = function() {
+	Polycode.SceneLabel_getText(this.__ptr)
+}
+
+SceneLabel.prototype.setLabelActualHeight = function(actualHeight) {
+	Polycode.SceneLabel_setLabelActualHeight(this.__ptr, actualHeight)
+}
+
+SceneLabel.prototype.getLabelActualHeight = function() {
+	Polycode.SceneLabel_getLabelActualHeight(this.__ptr)
+}
+
+SceneLabel.prototype.Render = function(buffer) {
+	Polycode.SceneLabel_Render(this.__ptr, buffer)
+}
+
+SceneLabel.prototype.getTextWidthForString = function(text) {
+	Polycode.SceneLabel_getTextWidthForString(this.__ptr, text)
+}
+
+SceneLabel.prototype.setText = function(newText) {
+	Polycode.SceneLabel_setText(this.__ptr, newText)
+}
+
+SceneLabel.prototype.Clone = function(deepClone,ignoreEditorOnly) {
+	Polycode.SceneLabel_Clone(this.__ptr, deepClone,ignoreEditorOnly)
+}
+
+SceneLabel.prototype.applyClone = function(clone,deepClone,ignoreEditorOnly) {
+	Polycode.SceneLabel_applyClone(this.__ptr, clone,deepClone,ignoreEditorOnly)
+}
+
+SceneLabel.prototype.updateFromLabel = function() {
+	Polycode.SceneLabel_updateFromLabel(this.__ptr)
+}
+
+SceneLabel.prototype.getLabel = function() {
+	Polycode.SceneLabel_getLabel(this.__ptr)
+}

bindings/javascript/Polycode/SceneLight.js

@@ -0,0 +1,122 @@
+function SceneLight() {
+}
+
+SceneLight.prototype.getIntensity = function() {
+	Polycode.SceneLight_getIntensity(this.__ptr)
+}
+
+SceneLight.prototype.setIntensity = function(newIntensity) {
+	Polycode.SceneLight_setIntensity(this.__ptr, newIntensity)
+}
+
+SceneLight.prototype.setAttenuation = function(constantAttenuation,linearAttenuation,quadraticAttenuation) {
+	Polycode.SceneLight_setAttenuation(this.__ptr, constantAttenuation,linearAttenuation,quadraticAttenuation)
+}
+
+SceneLight.prototype.getConstantAttenuation = function() {
+	Polycode.SceneLight_getConstantAttenuation(this.__ptr)
+}
+
+SceneLight.prototype.getLinearAttenuation = function() {
+	Polycode.SceneLight_getLinearAttenuation(this.__ptr)
+}
+
+SceneLight.prototype.getQuadraticAttenuation = function() {
+	Polycode.SceneLight_getQuadraticAttenuation(this.__ptr)
+}
+
+SceneLight.prototype.getType = function() {
+	Polycode.SceneLight_getType(this.__ptr)
+}
+
+SceneLight.prototype.renderDepthMap = function(scene) {
+	Polycode.SceneLight_renderDepthMap(this.__ptr, scene)
+}
+
+SceneLight.prototype.getZBufferTexture = function() {
+	Polycode.SceneLight_getZBufferTexture(this.__ptr)
+}
+
+SceneLight.prototype.setSpecularLightColor = function(r,g,b,a) {
+	Polycode.SceneLight_setSpecularLightColor(this.__ptr, r,g,b,a)
+}
+
+SceneLight.prototype.setDiffuseLightColor = function(r,g,b,a) {
+	Polycode.SceneLight_setDiffuseLightColor(this.__ptr, r,g,b,a)
+}
+
+SceneLight.prototype.setLightColor = function(r,g,b,a) {
+	Polycode.SceneLight_setLightColor(this.__ptr, r,g,b,a)
+}
+
+SceneLight.prototype.setSpotlightProperties = function(spotlightCutoff,spotlightExponent) {
+	Polycode.SceneLight_setSpotlightProperties(this.__ptr, spotlightCutoff,spotlightExponent)
+}
+
+SceneLight.prototype.getSpotlightCutoff = function() {
+	Polycode.SceneLight_getSpotlightCutoff(this.__ptr)
+}
+
+SceneLight.prototype.getSpotlightExponent = function() {
+	Polycode.SceneLight_getSpotlightExponent(this.__ptr)
+}
+
+SceneLight.prototype.enableShadows = function(val,resolution) {
+	Polycode.SceneLight_enableShadows(this.__ptr, val,resolution)
+}
+
+SceneLight.prototype.setShadowMapFOV = function(fov) {
+	Polycode.SceneLight_setShadowMapFOV(this.__ptr, fov)
+}
+
+SceneLight.prototype.getShadowMapFOV = function() {
+	Polycode.SceneLight_getShadowMapFOV(this.__ptr)
+}
+
+SceneLight.prototype.getShadowMapResolution = function() {
+	Polycode.SceneLight_getShadowMapResolution(this.__ptr)
+}
+
+SceneLight.prototype.areShadowsEnabled = function() {
+	Polycode.SceneLight_areShadowsEnabled(this.__ptr)
+}
+
+SceneLight.prototype.getLightType = function() {
+	Polycode.SceneLight_getLightType(this.__ptr)
+}
+
+SceneLight.prototype.setLightImportance = function(newImportance) {
+	Polycode.SceneLight_setLightImportance(this.__ptr, newImportance)
+}
+
+SceneLight.prototype.getLightImportance = function() {
+	Polycode.SceneLight_getLightImportance(this.__ptr)
+}
+
+SceneLight.prototype.setLightType = function(lightType) {
+	Polycode.SceneLight_setLightType(this.__ptr, lightType)
+}
+
+SceneLight.prototype.Clone = function(deepClone,ignoreEditorOnly) {
+	Polycode.SceneLight_Clone(this.__ptr, deepClone,ignoreEditorOnly)
+}
+
+SceneLight.prototype.applyClone = function(clone,deepClone,ignoreEditorOnly) {
+	Polycode.SceneLight_applyClone(this.__ptr, clone,deepClone,ignoreEditorOnly)
+}
+
+SceneLight.prototype.getParentScene = function() {
+	Polycode.SceneLight_getParentScene(this.__ptr)
+}
+
+SceneLight.prototype.setParentScene = function(scene) {
+	Polycode.SceneLight_setParentScene(this.__ptr, scene)
+}
+
+SceneLight.prototype.getSpotlightCamera = function() {
+	Polycode.SceneLight_getSpotlightCamera(this.__ptr)
+}
+
+SceneLight.prototype.getLightInfo = function() {
+	Polycode.SceneLight_getLightInfo(this.__ptr)
+}

bindings/javascript/Polycode/SceneLine.js

@@ -0,0 +1,14 @@
+function SceneLine() {
+}
+
+SceneLine.prototype.setStart = function(startp) {
+	Polycode.SceneLine_setStart(this.__ptr, startp)
+}
+
+SceneLine.prototype.setEnd = function(endp) {
+	Polycode.SceneLine_setEnd(this.__ptr, endp)
+}
+
+SceneLine.prototype.Update = function() {
+	Polycode.SceneLine_Update(this.__ptr)
+}

bindings/javascript/Polycode/SceneManager.js

@@ -0,0 +1,38 @@
+function SceneManager() {
+}
+
+SceneManager.prototype.addScene = function(newScene) {
+	Polycode.SceneManager_addScene(this.__ptr, newScene)
+}
+
+SceneManager.prototype.removeScene = function(scene) {
+	Polycode.SceneManager_removeScene(this.__ptr, scene)
+}
+
+SceneManager.prototype.Update = function() {
+	Polycode.SceneManager_Update(this.__ptr)
+}
+
+SceneManager.prototype.fixedUpdate = function() {
+	Polycode.SceneManager_fixedUpdate(this.__ptr)
+}
+
+SceneManager.prototype.Render = function(viewport) {
+	Polycode.SceneManager_Render(this.__ptr, viewport)
+}
+
+SceneManager.prototype.renderVirtual = function() {
+	Polycode.SceneManager_renderVirtual(this.__ptr)
+}
+
+SceneManager.prototype.registerRenderTexture = function(renderTexture) {
+	Polycode.SceneManager_registerRenderTexture(this.__ptr, renderTexture)
+}
+
+SceneManager.prototype.unregisterRenderTexture = function(renderTexture) {
+	Polycode.SceneManager_unregisterRenderTexture(this.__ptr, renderTexture)
+}
+
+SceneManager.prototype.setRenderer = function(renderer) {
+	Polycode.SceneManager_setRenderer(this.__ptr, renderer)
+}

bindings/javascript/Polycode/SceneMesh.js

@@ -0,0 +1,102 @@
+function SceneMesh() {
+}
+
+SceneMesh.prototype.Render = function(buffer) {
+	Polycode.SceneMesh_Render(this.__ptr, buffer)
+}
+
+SceneMesh.prototype.getShaderPass = function(index) {
+	Polycode.SceneMesh_getShaderPass(this.__ptr, index)
+}
+
+SceneMesh.prototype.getNumShaderPasses = function() {
+	Polycode.SceneMesh_getNumShaderPasses(this.__ptr)
+}
+
+SceneMesh.prototype.addShaderPass = function(pass) {
+	Polycode.SceneMesh_addShaderPass(this.__ptr, pass)
+}
+
+SceneMesh.prototype.removeShaderPass = function(shaderIndex) {
+	Polycode.SceneMesh_removeShaderPass(this.__ptr, shaderIndex)
+}
+
+SceneMesh.prototype.getMesh = function() {
+	Polycode.SceneMesh_getMesh(this.__ptr)
+}
+
+SceneMesh.prototype.getMaterial = function() {
+	Polycode.SceneMesh_getMaterial(this.__ptr)
+}
+
+SceneMesh.prototype.loadSkeleton = function(fileName) {
+	Polycode.SceneMesh_loadSkeleton(this.__ptr, fileName)
+}
+
+SceneMesh.prototype.clearMaterial = function() {
+	Polycode.SceneMesh_clearMaterial(this.__ptr)
+}
+
+SceneMesh.prototype.setMaterial = function(material) {
+	Polycode.SceneMesh_setMaterial(this.__ptr, material)
+}
+
+SceneMesh.prototype.rebuildAttributes = function() {
+	Polycode.SceneMesh_rebuildAttributes(this.__ptr)
+}
+
+SceneMesh.prototype.setMaterialByName = function(materialName,resourcePool) {
+	Polycode.SceneMesh_setMaterialByName(this.__ptr, materialName,resourcePool)
+}
+
+SceneMesh.prototype.setMesh = function(mesh) {
+	Polycode.SceneMesh_setMesh(this.__ptr, mesh)
+}
+
+SceneMesh.prototype.setSkeleton = function(skeleton) {
+	Polycode.SceneMesh_setSkeleton(this.__ptr, skeleton)
+}
+
+SceneMesh.prototype.getSkeleton = function() {
+	Polycode.SceneMesh_getSkeleton(this.__ptr)
+}
+
+SceneMesh.prototype.applySkeletonLocally = function() {
+	Polycode.SceneMesh_applySkeletonLocally(this.__ptr)
+}
+
+SceneMesh.prototype.setLineWidth = function(newWidth) {
+	Polycode.SceneMesh_setLineWidth(this.__ptr, newWidth)
+}
+
+SceneMesh.prototype.getFilename = function() {
+	Polycode.SceneMesh_getFilename(this.__ptr)
+}
+
+SceneMesh.prototype.setFilename = function(fileName) {
+	Polycode.SceneMesh_setFilename(this.__ptr, fileName)
+}
+
+SceneMesh.prototype.loadFromFile = function(fileName) {
+	Polycode.SceneMesh_loadFromFile(this.__ptr, fileName)
+}
+
+SceneMesh.prototype.customHitDetection = function(ray) {
+	Polycode.SceneMesh_customHitDetection(this.__ptr, ray)
+}
+
+SceneMesh.prototype.setForceMaterial = function(forceMaterial) {
+	Polycode.SceneMesh_setForceMaterial(this.__ptr, forceMaterial)
+}
+
+SceneMesh.prototype.getForceMaterial = function() {
+	Polycode.SceneMesh_getForceMaterial(this.__ptr)
+}
+
+SceneMesh.prototype.Clone = function(deepClone,ignoreEditorOnly) {
+	Polycode.SceneMesh_Clone(this.__ptr, deepClone,ignoreEditorOnly)
+}
+
+SceneMesh.prototype.applyClone = function(clone,deepClone,ignoreEditorOnly) {
+	Polycode.SceneMesh_applyClone(this.__ptr, clone,deepClone,ignoreEditorOnly)
+}

bindings/javascript/Polycode/SceneParticle.js

@@ -0,0 +1,2 @@
+function SceneParticle() {
+}

bindings/javascript/Polycode/SceneParticleEmitter.js

@@ -0,0 +1,178 @@
+function SceneParticleEmitter() {
+}
+
+SceneParticleEmitter.prototype.setParticleCount = function(newParticleCount) {
+	Polycode.SceneParticleEmitter_setParticleCount(this.__ptr, newParticleCount)
+}
+
+SceneParticleEmitter.prototype.getParticleCount = function() {
+	Polycode.SceneParticleEmitter_getParticleCount(this.__ptr)
+}
+
+SceneParticleEmitter.prototype.setParticleLifetime = function(lifetime) {
+	Polycode.SceneParticleEmitter_setParticleLifetime(this.__ptr, lifetime)
+}
+
+SceneParticleEmitter.prototype.getParticleLifetime = function() {
+	Polycode.SceneParticleEmitter_getParticleLifetime(this.__ptr)
+}
+
+SceneParticleEmitter.prototype.setDirectionDeviation = function(newDeviation) {
+	Polycode.SceneParticleEmitter_setDirectionDeviation(this.__ptr, newDeviation)
+}
+
+SceneParticleEmitter.prototype.getDirectionDeviation = function() {
+	Polycode.SceneParticleEmitter_getDirectionDeviation(this.__ptr)
+}
+
+SceneParticleEmitter.prototype.setEmitterSize = function(newSize) {
+	Polycode.SceneParticleEmitter_setEmitterSize(this.__ptr, newSize)
+}
+
+SceneParticleEmitter.prototype.getEmitterSize = function() {
+	Polycode.SceneParticleEmitter_getEmitterSize(this.__ptr)
+}
+
+SceneParticleEmitter.prototype.setGravity = function(newGravity) {
+	Polycode.SceneParticleEmitter_setGravity(this.__ptr, newGravity)
+}
+
+SceneParticleEmitter.prototype.getGravity = function() {
+	Polycode.SceneParticleEmitter_getGravity(this.__ptr)
+}
+
+SceneParticleEmitter.prototype.fixedUpdate = function() {
+	Polycode.SceneParticleEmitter_fixedUpdate(this.__ptr)
+}
+
+SceneParticleEmitter.prototype.Render = function(buffer) {
+	Polycode.SceneParticleEmitter_Render(this.__ptr, buffer)
+}
+
+SceneParticleEmitter.prototype.updateParticles = function() {
+	Polycode.SceneParticleEmitter_updateParticles(this.__ptr)
+}
+
+SceneParticleEmitter.prototype.rebuildParticles = function(buffer) {
+	Polycode.SceneParticleEmitter_rebuildParticles(this.__ptr, buffer)
+}
+
+SceneParticleEmitter.prototype.triggerParticles = function(allAtOnce) {
+	Polycode.SceneParticleEmitter_triggerParticles(this.__ptr, allAtOnce)
+}
+
+SceneParticleEmitter.prototype.enableParticleSystem = function(val) {
+	Polycode.SceneParticleEmitter_enableParticleSystem(this.__ptr, val)
+}
+
+SceneParticleEmitter.prototype.setUseFloorPlane = function(val) {
+	Polycode.SceneParticleEmitter_setUseFloorPlane(this.__ptr, val)
+}
+
+SceneParticleEmitter.prototype.setFloorPlaneOffset = function(floorPlaneOffset) {
+	Polycode.SceneParticleEmitter_setFloorPlaneOffset(this.__ptr, floorPlaneOffset)
+}
+
+SceneParticleEmitter.prototype.setFloorDamping = function(floorDamping) {
+	Polycode.SceneParticleEmitter_setFloorDamping(this.__ptr, floorDamping)
+}
+
+SceneParticleEmitter.prototype.setParticlesInWorldSpace = function(val) {
+	Polycode.SceneParticleEmitter_setParticlesInWorldSpace(this.__ptr, val)
+}
+
+SceneParticleEmitter.prototype.getParticlesInWorldSpace = function() {
+	Polycode.SceneParticleEmitter_getParticlesInWorldSpace(this.__ptr)
+}
+
+SceneParticleEmitter.prototype.setPerlinEnabled = function(val) {
+	Polycode.SceneParticleEmitter_setPerlinEnabled(this.__ptr, val)
+}
+
+SceneParticleEmitter.prototype.getPerlinEnabled = function() {
+	Polycode.SceneParticleEmitter_getPerlinEnabled(this.__ptr)
+}
+
+SceneParticleEmitter.prototype.getParticleSpeed = function() {
+	Polycode.SceneParticleEmitter_getParticleSpeed(this.__ptr)
+}
+
+SceneParticleEmitter.prototype.setParticleSpeed = function(speed) {
+	Polycode.SceneParticleEmitter_setParticleSpeed(this.__ptr, speed)
+}
+
+SceneParticleEmitter.prototype.setPerlinValue = function(perlinValue) {
+	Polycode.SceneParticleEmitter_setPerlinValue(this.__ptr, perlinValue)
+}
+
+SceneParticleEmitter.prototype.getPerlinValue = function() {
+	Polycode.SceneParticleEmitter_getPerlinValue(this.__ptr)
+}
+
+SceneParticleEmitter.prototype.setParticleType = function(particleType) {
+	Polycode.SceneParticleEmitter_setParticleType(this.__ptr, particleType)
+}
+
+SceneParticleEmitter.prototype.getParticleType = function() {
+	Polycode.SceneParticleEmitter_getParticleType(this.__ptr)
+}
+
+SceneParticleEmitter.prototype.setParticleSize = function(particleSize) {
+	Polycode.SceneParticleEmitter_setParticleSize(this.__ptr, particleSize)
+}
+
+SceneParticleEmitter.prototype.getParticleSize = function() {
+	Polycode.SceneParticleEmitter_getParticleSize(this.__ptr)
+}
+
+SceneParticleEmitter.prototype.setParticleRotationSpeed = function(rotationSpeed) {
+	Polycode.SceneParticleEmitter_setParticleRotationSpeed(this.__ptr, rotationSpeed)
+}
+
+SceneParticleEmitter.prototype.getParticleRotationSpeed = function() {
+	Polycode.SceneParticleEmitter_getParticleRotationSpeed(this.__ptr)
+}
+
+SceneParticleEmitter.prototype.setParticleDirection = function(direction) {
+	Polycode.SceneParticleEmitter_setParticleDirection(this.__ptr, direction)
+}
+
+SceneParticleEmitter.prototype.getParticleDirection = function() {
+	Polycode.SceneParticleEmitter_getParticleDirection(this.__ptr)
+}
+
+SceneParticleEmitter.prototype.setLoopParticles = function(val) {
+	Polycode.SceneParticleEmitter_setLoopParticles(this.__ptr, val)
+}
+
+SceneParticleEmitter.prototype.getLoopParticles = function() {
+	Polycode.SceneParticleEmitter_getLoopParticles(this.__ptr)
+}
+
+SceneParticleEmitter.prototype.addSourceMesh = function(mesh) {
+	Polycode.SceneParticleEmitter_addSourceMesh(this.__ptr, mesh)
+}
+
+SceneParticleEmitter.prototype.getNumSourceMeshes = function() {
+	Polycode.SceneParticleEmitter_getNumSourceMeshes(this.__ptr)
+}
+
+SceneParticleEmitter.prototype.getSourcesMeshAtIndex = function(index) {
+	Polycode.SceneParticleEmitter_getSourcesMeshAtIndex(this.__ptr, index)
+}
+
+SceneParticleEmitter.prototype.removeSourceMeshAtIndex = function(index) {
+	Polycode.SceneParticleEmitter_removeSourceMeshAtIndex(this.__ptr, index)
+}
+
+SceneParticleEmitter.prototype.positionParticle = function(index) {
+	Polycode.SceneParticleEmitter_positionParticle(this.__ptr, index)
+}
+
+SceneParticleEmitter.prototype.Clone = function(deepClone,ignoreEditorOnly) {
+	Polycode.SceneParticleEmitter_Clone(this.__ptr, deepClone,ignoreEditorOnly)
+}
+
+SceneParticleEmitter.prototype.applyClone = function(clone,deepClone,ignoreEditorOnly) {
+	Polycode.SceneParticleEmitter_applyClone(this.__ptr, clone,deepClone,ignoreEditorOnly)
+}

bindings/javascript/Polycode/ScenePrimitive.js

@@ -0,0 +1,42 @@
+function ScenePrimitive() {
+}
+
+ScenePrimitive.prototype.setPrimitiveOptions = function(type,v1,v2,v3,v4,v5) {
+	Polycode.ScenePrimitive_setPrimitiveOptions(this.__ptr, type,v1,v2,v3,v4,v5)
+}
+
+ScenePrimitive.prototype.recreatePrimitive = function() {
+	Polycode.ScenePrimitive_recreatePrimitive(this.__ptr)
+}
+
+ScenePrimitive.prototype.getPrimitiveType = function() {
+	Polycode.ScenePrimitive_getPrimitiveType(this.__ptr)
+}
+
+ScenePrimitive.prototype.getPrimitiveParameter1 = function() {
+	Polycode.ScenePrimitive_getPrimitiveParameter1(this.__ptr)
+}
+
+ScenePrimitive.prototype.getPrimitiveParameter2 = function() {
+	Polycode.ScenePrimitive_getPrimitiveParameter2(this.__ptr)
+}
+
+ScenePrimitive.prototype.getPrimitiveParameter3 = function() {
+	Polycode.ScenePrimitive_getPrimitiveParameter3(this.__ptr)
+}
+
+ScenePrimitive.prototype.getPrimitiveParameter4 = function() {
+	Polycode.ScenePrimitive_getPrimitiveParameter4(this.__ptr)
+}
+
+ScenePrimitive.prototype.getPrimitiveParameter5 = function() {
+	Polycode.ScenePrimitive_getPrimitiveParameter5(this.__ptr)
+}
+
+ScenePrimitive.prototype.Clone = function(deepClone,ignoreEditorOnly) {
+	Polycode.ScenePrimitive_Clone(this.__ptr, deepClone,ignoreEditorOnly)
+}
+
+ScenePrimitive.prototype.applyClone = function(clone,deepClone,ignoreEditorOnly) {
+	Polycode.ScenePrimitive_applyClone(this.__ptr, clone,deepClone,ignoreEditorOnly)
+}

bindings/javascript/Polycode/SceneRenderTexture.js

@@ -0,0 +1,34 @@
+function SceneRenderTexture() {
+}
+
+SceneRenderTexture.prototype.getTargetTexture = function() {
+	Polycode.SceneRenderTexture_getTargetTexture(this.__ptr)
+}
+
+SceneRenderTexture.prototype.getFilterColorBufferTexture = function() {
+	Polycode.SceneRenderTexture_getFilterColorBufferTexture(this.__ptr)
+}
+
+SceneRenderTexture.prototype.getFilterZBufferTexture = function() {
+	Polycode.SceneRenderTexture_getFilterZBufferTexture(this.__ptr)
+}
+
+SceneRenderTexture.prototype.Render = function() {
+	Polycode.SceneRenderTexture_Render(this.__ptr)
+}
+
+SceneRenderTexture.prototype.saveToImage = function() {
+	Polycode.SceneRenderTexture_saveToImage(this.__ptr)
+}
+
+SceneRenderTexture.prototype.resizeRenderTexture = function(newWidth,newHeight) {
+	Polycode.SceneRenderTexture_resizeRenderTexture(this.__ptr, newWidth,newHeight)
+}
+
+SceneRenderTexture.prototype.getTargetScene = function() {
+	Polycode.SceneRenderTexture_getTargetScene(this.__ptr)
+}
+
+SceneRenderTexture.prototype.getTargetCamera = function() {
+	Polycode.SceneRenderTexture_getTargetCamera(this.__ptr)
+}

bindings/javascript/Polycode/SceneSound.js

@@ -0,0 +1,34 @@
+function SceneSound() {
+}
+
+SceneSound.prototype.Update = function() {
+	Polycode.SceneSound_Update(this.__ptr)
+}
+
+SceneSound.prototype.Clone = function(deepClone,ignoreEditorOnly) {
+	Polycode.SceneSound_Clone(this.__ptr, deepClone,ignoreEditorOnly)
+}
+
+SceneSound.prototype.applyClone = function(clone,deepClone,ignoreEditorOnly) {
+	Polycode.SceneSound_applyClone(this.__ptr, clone,deepClone,ignoreEditorOnly)
+}
+
+SceneSound.prototype.isDirectionalSound = function() {
+	Polycode.SceneSound_isDirectionalSound(this.__ptr)
+}
+
+SceneSound.prototype.setDirectionalSound = function(val) {
+	Polycode.SceneSound_setDirectionalSound(this.__ptr, val)
+}
+
+SceneSound.prototype.getSound = function() {
+	Polycode.SceneSound_getSound(this.__ptr)
+}
+
+SceneSound.prototype.setLoopOnLoad = function(val) {
+	Polycode.SceneSound_setLoopOnLoad(this.__ptr, val)
+}
+
+SceneSound.prototype.getLoopOnLoad = function() {
+	Polycode.SceneSound_getLoopOnLoad(this.__ptr)
+}