Updated CHANGELOG for 0.40.

LuaDist relies on using liblua.dylib for all its modules with the same
name for both Lua 5.1 and Lua 5.2 interpreters. This presents an issue for
ZBS as it needs not only to refer to a proper liblua.dylib, but also to
avoid loading two interpreters as its own interperter loads its own
library.

To resolve this, liblua.dylib doesn't export any symbols (it's a dummy
library), but it needs to be present to satisfy dyld dependency (as some
of the libraries and LuaDist build process are outside of our control).

All the other Lua symbols are already available in memory, but to make
LuaDist libraries to use them, we enforce flat namespace.

LICENSE

@@ -49,7 +49,7 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 THE SOFTWARE.
 
---[[ wxLua License License ]]----------------------------------------------
+--[[ wxLua License ]]------------------------------------------------------
 
 http://wxlua.sourceforge.net/
 
@@ -61,7 +61,7 @@ Original wxLua Lua sample IDE:
   luascript at thersgb.net
 
 wxLua is based on 
-wxWindows Library Licence, Version 3
+wxWindows Library License, Version 3
 
 Copyright (c) 1998 Julian Smart, Robert Roebling et al
 
@@ -136,49 +136,87 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 
 SOFTWARE. 
 
---[[ LuaFileSystem License ]]----------------------------------------------
-
-LuaFileSystem was designed by Roberto Ierusalimschy, André Carregal and Tomás 
-Guisasola as part of the Kepler Project, which holds its copyright.
-Homepage: http://www.keplerproject.org/luafilesystem/index.html
-License:  http://www.keplerproject.org/luafilesystem/license.html
-
 --[[ LuaSockets License ]]-------------------------------------------------
 
 Copyright: © 2004-2006 Diego Nehab. All rights reserved.
 Homepage: http://www.cs.princeton.edu/~diego/professional/luasocket/
 License:  http://www.lua.org/copyright.html (same as LUA)
 
---[[ ZMQ License ]]--------------------------------------------------------
+--[[ Serpent License ]]----------------------------------------------------
 
-Copyright: © 2007-2011 iMatix Corporation and Contributors
-Homepage: http://www.zeromq.org/
-License:  http://www.zeromq.org/area:licensing
-
-LuaZMQ
-Copyright: © 2011 by Robert G. Jakabosky
-Homepage: https://github.com/Neopallium/lua-zmq
-
---[[ MojoShader License ]]-------------------------------------------------
-
-Copyright: © 2008-2010 Ryan C. Gordon
-Homepage: http://icculus.org/mojoshader/
-License:  http://hg.icculus.org/icculus/mojoshader/raw-file/tip/LICENSE.txt
-
---[[ CLCC License ]]-------------------------------------------------------
-
-Copyright: © 2009 Organic Vectory B.V.
-Homepage: http://clcc.sourceforge.net/
-License:  boost
-
-CLCC was modified by Christoph Kubisch to support multiple platforms and
-output file generation.
-
---[[ MobDebug License ]]---------------------------------------------------
-
-MobDebug sources are released under the MIT License
-
-Copyright (c) 2011 Paul Kulchenko (paul@kulchenko.com)
+Copyright (c) 2011-2013 Paul Kulchenko (paul@kulchenko.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+--[[ LuaJIT License ]]-----------------------------------------------------
+
+Copyright © 2005-2013 Mike Pall, released under the MIT open source license.
+
+--[[ WinAPI License ]]-----------------------------------------------------
+
+Copyright (C) 2011 Steve Donovan.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+--[[ MobDebug License ]]---------------------------------------------------
+
+MobDebug sources are released under the MIT License
+
+Copyright (c) 2011-2012 Paul Kulchenko (paul@kulchenko.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+--[[ RemDebug License ]]---------------------------------------------------
+
+Copyright (c) 2006 The Kepler Project.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,70 +1,84 @@
 # Project Description
 
-A simple and extensible Lua IDE and debugger. It supports multiple file
-formats, "api" for autocompletion and tooltips, and custom command-line
-tools. Its main focus is extensibility for target applications using Lua.
+[ZeroBrane Studio](http://studio.zerobrane.com/) is a lightweight Lua IDE with code completion, syntax
+highlighting, remote debugger, code analyzer, live coding, and debugging
+support for several Lua engines (LuaJIT, Löve 2D, Moai, Gideros, Corona, Marmalade Quick,
+MobileLua, GSL-shell, and others). It originated from the [Estrela Editor](http://www.luxinia.de/index.php/Estrela/).
 
 ## Features
 
-* Written in Lua, so easily customizable
-* Automatically loads several 'plugin' like classes
-  - applications: overall control of applications settings
-  - specs (spec/): file syntax, lexer, keywords
-  - apis (api/): for code-completion and tool-tips
-  - interpreters (interpreters/): how a project is run
-  - config (cfg/): contains style and basic editor settings
-  - tools (tools/): additional tools, e.g. cg compiler, dx fxc compiler
-* Auto-completion for functions, keywords...
-* Function tips
-* Function list in file (quick jump to)
-* Function call highlighting
-* Bracket matching/highlighting
-* Project file browser
-* Experimental type/class guessing for auto-completion
-* Support for different editor styles
-* Console to directly test code snippets with local and remote execution
-* Integrated debugger (with support for local and remote debugging)
+* Written in Lua, so easily customizable.
+* Small, portable, and cross-platform (Windows, Mac OSX, and Linux).
+* Auto-completion for functions, keywords, and custom APIs.
+* Interactive console to directly test code snippets with local and remote execution.
+* Integrated debugger with local and [remote debugging](http://studio.zerobrane.com/doc-remote-debugging.html) for Lua 5.1,
+[Lua 5.2](http://studio.zerobrane.com/doc-lua52-debugging.html),
+[LuaJIT](http://studio.zerobrane.com/doc-luajit-debugging.html),
+and [other Lua engines](http://studio.zerobrane.com/documentation.html#debugging).
+* Live coding with Lua ([demo](http://notebook.kulchenko.com/zerobrane/live-coding-in-lua-bret-victor-style)),
+Löve 2D ([demo](http://notebook.kulchenko.com/zerobrane/live-coding-with-love)),
+Gideros ([demo](http://notebook.kulchenko.com/zerobrane/gideros-live-coding-with-zerobrane-studio-ide)),
+Moai ([demo](http://notebook.kulchenko.com/zerobrane/live-coding-with-moai-and-zerobrane-studio)),
+and Corona SDK ([demo](http://notebook.kulchenko.com/zerobrane/debugging-and-live-coding-with-corona-sdk-applications-and-zerobrane-studio)).
+* Support for plugin-like components:
+  - specs (`spec/`): file syntax, lexer, and keywords;
+  - apis (`api/`): for code completion and tooltips;
+  - interpreters (`interpreters/`): components for setting debugging and run-time project environment;
+  - config (`cfg/`): contains style, color themes, and other settings;
+  - packages (`packages/`): plugins that provide additional functionality;
+  - tools (`tools/`): additional tools.
 
-## Frontends
+## Documentation
 
-There is currently two front-ends using the same editor engine. The original
-one is `Estrela`, which has a focus on 3d graphics related usage of Lua,
-especially in combination with the luxinia engine or luxinia2 framework.
-The second front-end is `ZeroBrane Studio` (zbstudio) which has a focus
-on using Lua in education, mobile development, and robotics.
+* A [short and simple overview](http://studio.zerobrane.com/doc-getting-started.html) for those who are new to this development environment.
+* A list of [frequently asked questions](http://studio.zerobrane.com/doc-faq.html) about the IDE.
+* [Tutorials and demos](http://studio.zerobrane.com/tutorials.html) that cover debugging and live coding for different environments.
+* [Tips and tricks](http://studio.zerobrane.com/doc-tips-and-tricks.html).
 
-Both are part of the standard distribution.
+## Screenshot
 
-## Installation
-
-```bash
-$ git clone git://github.com/pkulchenko/ZeroBraneStudio.git zbstudio
-  or
-$ git clone git://estrelaeditor.git.sourceforge.net/gitroot/estrelaeditor/estrelaeditor estrelaeditor
-```
+![ZeroBrane Studio debugger screenshot](http://studio.zerobrane.com/images/debugging.png)
 
 ## Usage
 
 ```
-Open File(s):
-  <exe> <filename> [<filename>...]
+Open file(s):
+  zbstudio <filename> [<filename>...]
   any non-option will be treated as filename
 
-Overriding Config:
-  <exe> [...] -cfg "<luacode overriding config>" [...]
-  e.g.: zbstudio.exe -cfg "singleinstance=false;" somefile.lua
+Set project directory:
+  zbstudio <project directory> [<filename>...]
+  (0.39+) a directory passed as a parameter will be set as the project directory
+
+Overriding default configuration:
+  zbstudio -cfg "<luacode overriding config>" [<filename>]
+  e.g.: zbstudio -cfg "editor.fontsize=12" somefile.lua
+
+Loading custom configuration:
+  zbstudio -cfg path/file.lua [<filename>]
+  e.g.: zbstudio -cfg cfg/estrela.lua
 ```
 
 ## Author
 
-### Estrela Editor
-
-  **Luxinia Dev:** Christoph Kubisch (crazybutcher@luxinia.de)
-
 ### ZeroBrane Studio and MobDebug
 
   **ZeroBrane LLC:** Paul Kulchenko (paul@kulchenko.com)
 
+### Estrela Editor
+
+  **Luxinia Dev:** Christoph Kubisch (crazybutcher@luxinia.de)
+
+## Where is Estrela?
+
+The projects have been merged and ZeroBrane Studio will lead the future.
+Please reassociate files with ZeroBrane Studio. To keep your history of files
+and projects copy the contents of the `EstrelaEditor.ini` in your HOME
+directory to `ZeroBraneStudio.ini`. If you have used Estrela for graphics
+shader authoring or luxinia, create/modify the `cfg/user.lua` to include the
+content of `cfg/estrela.lua` to load all tools and specifications by default
+again.
+  
 ## License
 
 See LICENSE file.

api/glsl/std.lua

@@ -64,6 +64,11 @@ smoothstep = fn "clip and smooth blend [a,b]. - (vecN)(vecN a, b, x)",
 floatBitsToInt = fn "returns the 32-bit integer representation of an IEEE 754 floating-point scalar or vector - (uintN/intN)(floatN)",
 intBitsToFloat = fn "returns the float value corresponding to a given bit represention.of a scalar int value or vector of int values. - (floatN)(intN)",
 uintBitsToFloat = fn "returns the float value corresponding to a given bit represention.of a scalar int value or vector of int values. - (floatN)(uintN)",
+doubleBitsToInt64 = fn "returns the 64-bit integer representation of an IEEE 754 double precision floating-point scalar or vector - (int64N)(doubleN)",
+doubleBitsToUint64 = fn "returns the 64-bit integer representation of an IEEE 754 double precision floating-point scalar or vector - (uint64N)(doubleN)",
+int64BitsToDouble =  fn "returns the double value corresponding to a given bit represention.of a scalar int value or vector of int values. - (doubleN)(uint64N)",
+uint64BitsToDouble =  fn "returns the double value corresponding to a given bit represention.of a scalar int value or vector of int values. - (doubleN)(uint64N)",
+
 fma = fn "return a*b + c, treated as single operation when using precise - (vecN a, vecN b, vecN c)",
 frexp = fn "splits scalars and vectors into normalized fraction [0.5,1.0) and a power of 2. - (vecN)(vecN x, out vecN e)",
 ldexp = fn "build floating point number from x and the corresponding integral exponen of 2 in exp. - (vecN)(vecN x, exp)",
@@ -71,13 +76,21 @@ ldexp = fn "build floating point number from x and the corresponding integral ex
 packUnorm2x16 = fn "Converts each comp. of v into 16-bit ints, packs results into the returned 32-bit uint. - (uint)(vec2 v)",
 packUnorm4x8 = fn "Converts each comp. of v into 8-bit ints, packs results into the returned 32-bit uint. - (uint)(vec4 v)",
 packSnorm4x8 = fn "Converts each comp. of v into 8-bit ints, packs results into the returned 32-bit uint. - (uint)(vec4 v)",
+packDouble2x32 = fn "Packs components of v into a 64-bit value and returns a double-prec value. - (double)(uvec2 v)",
+packHalf2x16 = fn "Converts each comp. of v into 16-bit half float, packs results into the returned 32-bit uint. - (uint)(vec2 v)",
+packInt2x32 = fn "Packs two 32 bit into one 64-bit value. - (int64_t)(ivec2)",
+packUint2x32 = fn "Packs two 32 bit into one 64-bit value. - (uint64_t)(uvec2)",
+packFloat2x16 = fn "returns an unsigned integer obtained by interpreting the components of a two-component 16-bit floating-point as integers and packing them into 32 bit. - (uint)(f16vec2  v)",
 
 unpackUnorm2x16 = fn "Unpacks 32-bit p into two 16-bit uints and converts them to normalized float. - (vec2)(uint p)",
 unpackUnorm4x8 = fn "Unpacks 32-bit p into four 8-bit uints and converts them to normalized float. - (vec4)(uint p)",
 unpackSnorm4x8 = fn "Unpacks 32-bit p into four 8-bit uints and converts them to normalized float. - (vec4)(uint p)",
-
-packDouble2x32 = fn "Packs components of v into a 64-bit value and returns a double-prec value. - (double)(uvec2 v)",
 unpackDouble2x32 = fn "Returns a 2 component vector representation of v. - (uvec2)(double v)",
+unpackHalf2x16 = fn "Interprets p as two 16-bit half floats and returns them as vector. - (vec2)(uint p)",
+unpackInt2x32  = fn "Unpacks 64-bit into two 32-bit values. - (ivec2)(int64_t)",
+unpackUint2x32 = fn "Unpacks 64-bit into two 32-bit values. - (uvec2)(uint64_t)",
+unpackFloat2x16 = fn "returns a two-component vector with 16-bit floating-point components obtained by unpacking a 32-bit unsigned integer into a pair of 16-bit values. - (f16vec2)(uint)",
+
 
 length = fn "return scalar Euclidean length of a vector. - (type)(vecN)",
 distance = fn "return the Euclidean distance between two points. - (vecN)(vecN a, b)",
@@ -135,6 +148,11 @@ EndPrimitive = fn "Completes current output primitive and starts a new one. - ()
 barrier = fn "Synchronizes across shader invocations. - ()()",
 
 memoryBarrier = fn "control ordering of memory transactions issued by shader thread. - ()()",
+memoryBarrierAtomicCounter = fn "control ordering of memory transactions issued by shader thread. - ()()",
+memoryBarrierShared = fn "control ordering of memory transactions issued by shader thread. - ()()",
+memoryBarrierBuffer = fn "control ordering of memory transactions issued by shader thread. - ()()",
+memoryBarrierImage = fn "control ordering of memory transactions issued by shader thread. - ()()",
+groupMemoryBarrier = fn "control ordering of memory transactions issued by shader thread. - ()()",
 imageAtomicAdd = fn "performs atomic operation on individual texels returns new value. - (uint)(imageN, intN coord, [int sample], uint data)",
 imageAtomicMin = fn "performs atomic operation on individual texels returns new value. - (uint)(imageN, intN coord, [int sample], uint data)",
 imageAtomicMax = fn "performs atomic operation on individual texels returns new value. - (uint)(imageN, intN coord, [int sample], uint data)",
@@ -164,44 +182,72 @@ textureGather = fn "gather lookup (pixel quad of 4 single channel samples at onc
 textureGatherOffset = fn "gather lookup (pixel quad of 4 single channel samples at once) with offset. Component 0: x, 1: y ... is ignored for shadow samplers instead reference value must be passed. Only 2D/Cube. Illegal for MS. - (vec4)(samplerN, vecN coord, [float shadowRefZ], intN offset / intN offset[4] , [int comp])",
 texelFetch = fn "integer coordinate lookup for a single texel. No lod parameter for Buffer, MS, Rect. Illegal for Cube - (vec4)(samplerN, intN coord, [int lod/sample])",
 texelFetchOffset = fn "integer coordinate lookup for a single texel with offset. No lod parameter for Buffer, MS, Rect. Illegal for Cube, Buffer, MS. - (vec4)(samplerN, intN coord, [int lod/sample], intN offset)",
+
+anyInvocationARB = fn "returns true if and only if <value> is true for at least one active invocation in the group. - (bool)(bool value)",
+allInvocationsARB = fn "returns true if and only if <value> is true for all active invocations in the group - (bool)(bool value)",
+allInvocationsEqualARB = fn "returns true if <value> is the same for all active invocation in the group. - (bool)(bool value)",
 }
 
 local keyw = 
-[[int uint half float bool double
-vec2 vec3 vec4 dvec2 dvec3 dvec4
-ivec2 ivec3 ivec4 uvec2 uvec3 uvec4 bvec2 bvec3 bvec4
-mat2 mat3 mat4 mat2x2 mat3x3 mat4x4 mat2x3 mat3x2 mat4x2 mat2x4 mat4x3 mat3x4
-dmat2 dmat3 dmat4 dmat2x2 dmat3x3 dmat4x4 dmat2x3 dmat3x2 dmat4x2 dmat2x4 dmat4x3 dmat3x4
-struct typedef void
-usampler1D usampler2D usampler3D usampler2DRect usamplerCube isampler1DArray usampler2DARRAY usamplerCubeArray usampler2DMS usampler2DMSArray
-isampler1D isampler2D isampler3D isampler2DRect isamplerCube isampler1DArray isampler2DARRAY isamplerCubeArray isampler2DMS isampler2DMSArray
-sampler1D sampler2D sampler3D sampler2DRect samplerCube sampler1DArray sampler2DArray samplerCubeArray sampler2DMS sampler2DMSArray
-sampler1DShadow sampler2DShadow sampler2DRectShadow sampler1DArrayShadow sampler2DArrayShadow samplerCubeArrayShadow
-usamplerBuffer isamplerBuffer samplerBuffer
-in out inout uniform const centroid sample attribute varying patch
-return switch case for do while if else break continue
-layout location vertices line_strip triangle_strip max_vertices stream
-triangles quads equal_spacing isolines fractional_even_spacing
-fractional_odd_spacing cw ccw point_mode lines_adjacency triangles_adjacency
-invocations
-origin_upper_left pixel_center_integer
-smooth flat noperspective highp mediump lowp shared packed std140 row_major column_major
-gl_FrontColor gl_BackColor gl_FrontSecondaryColor gl_BackSecondaryColor gl_Color gl_SecondaryColor
-subroutine gl_Position
-gl_VertexID gl_InstanceID gl_Normal gl_Vertex gl_MultiTexCoord0 gl_MultiTexCoord1
-gl_MultiTexCoord2 gl_MultiTexCoord3 gl_MultiTexCoord4 gl_MultiTexCoord5 gl_MultiTexCoord6
-gl_MultiTexCoord7 gl_FogCoord gl_PointSize gl_ClipDistance
-gl_TexCoord gl_FogFragCoord gl_ClipVertex gl_in
-gl_PatchVerticesIn
-gl_PrimitiveID gl_InvocationID gl_TessLevelOuter gl_TessLevelInner gl_TessCoord
-gl_InvocationID gl_PrimitiveIDIn gl_Layer gl_ViewportIndex gl_FrontFacing
-gl_PointCoord gl_SampleID gl_SamplePosition gl_FragColor
-gl_FragData gl_FragDepth gl_SampleMask
+[[  int uint half float bool double atomic_uint binding offset
+    vec2 vec3 vec4 dvec2 dvec3 dvec4
+    ivec2 ivec3 ivec4 uvec2 uvec3 uvec4 bvec2 bvec3 bvec4
+    mat2 mat3 mat4 mat2x2 mat3x3 mat4x4 mat2x3 mat3x2 mat4x2 mat2x4 mat4x3 mat3x4
+    dmat2 dmat3 dmat4 dmat2x2 dmat3x3 dmat4x4 dmat2x3 dmat3x2 dmat4x2 dmat2x4 dmat4x3 dmat3x4
+    float16_t f16vec2 f16vec3 f16vec4
+    float32_t f32vec2 f32vec3 f32vec4
+    float64_t f64vec2 f64vec3 f64vec4
+    int8_t i8vec2 i8vec3 i8vec4
+    int8_t i8vec2 i8vec3 i8vec4
+    int16_t i16vec2 i16vec3 i16vec4
+    int32_t i32vec2 i32vec3 i32vec4
+    int64_t i64vec2 i64vec3 i64vec4
+    uint8_t u8vec2 u8vec3 u8vec4
+    uint16_t u16vec2 u16vec3 u16vec4
+    uint32_t u32vec2 u32vec3 u32vec4
+    uint64_t u64vec2 u64vec3 u64vec4
+    struct typedef void
+    usampler1D usampler2D usampler3D usampler2DRect usamplerCube isampler1DArray usampler2DARRAY usamplerCubeArray usampler2DMS usampler2DMSArray
+    isampler1D isampler2D isampler3D isampler2DRect isamplerCube isampler1DArray isampler2DARRAY isamplerCubeArray isampler2DMS isampler2DMSArray
+    sampler1D sampler2D sampler3D sampler2DRect samplerCube sampler1DArray sampler2DArray samplerCubeArray sampler2DMS sampler2DMSArray
+    sampler1DShadow sampler2DShadow sampler2DRectShadow sampler1DArrayShadow sampler2DArrayShadow samplerCubeArrayShadow
+    usamplerBuffer isamplerBuffer samplerBuffer samplerRenderbuffer isamplerRenderbuffer usamplerRenderbuffer
+    in out inout uniform const centroid sample attribute varying patch index true false
+    return switch case for do while if else break continue main inline
+    layout location vertices line_strip triangle_strip max_vertices stream
+    triangles quads equal_spacing isolines fractional_even_spacing lines points
+    fractional_odd_spacing cw ccw point_mode lines_adjacency triangles_adjacency
+    invocations offset align xfb_offset xfb_buffer
+    origin_upper_left pixel_center_integer depth_greater depth_greater depth_greater depth_unchanged
+    smooth flat noperspective highp mediump lowp shared packed std140 std430 row_major column_major buffer
+    gl_FrontColor gl_BackColor gl_FrontSecondaryColor gl_BackSecondaryColor gl_Color gl_SecondaryColor
+    subroutine gl_Position gl_FragCoord
+    gl_VertexID gl_InstanceID gl_Normal gl_Vertex gl_MultiTexCoord0 gl_MultiTexCoord1
+    gl_MultiTexCoord2 gl_MultiTexCoord3 gl_MultiTexCoord4 gl_MultiTexCoord5 gl_MultiTexCoord6
+    gl_MultiTexCoord7 gl_FogCoord gl_PointSize gl_ClipDistance
+    gl_TexCoord gl_FogFragCoord gl_ClipVertex gl_in
+    gl_PatchVerticesIn
+    gl_PrimitiveID gl_InvocationID gl_TessLevelOuter gl_TessLevelInner gl_TessCoord
+    gl_InvocationID gl_PrimitiveIDIn gl_Layer gl_ViewportIndex gl_FrontFacing
+    gl_PointCoord gl_SampleID gl_SamplePosition gl_FragColor
+    gl_FragData gl_FragDepth gl_SampleMask
+    gl_NumWorkGroups gl_WorkGroupSize gl_WorkGroupID gl_LocalInvocationID gl_GlobalInvocationID gl_LocalInvocationIndex
+    local_size_x local_size_y local_size_z
+    gl_BaseVertexARB gl_BaseInstanceARB gl_DrawIDARB
+    bindless_sampler bound_sampler bindless_image bound_image
+
+    coherent volatile restrict readonly writeonly
+    image1D image2D image3D image2DRect imageCube imageBuffer image1DArray image2DArray imageCubeArray image2DMS image2DMSArray
+    uimage1D uimage2D uimage3D uimage2DRect uimageCube uimageBuffer uimage1DArray uimage2DArray uimageCubeArray uimage2DMS uimage2DMSArray
+    iimage1D iimage2D iimage3D iimage2DRect iimageCube iimageBuffer iimage1DArray iimage2DArray iimageCubeArray iimage2DMS iimage2DMSArray
+    size1x8 size1x16 size1x32 size2x32 size4x32 rgba32f rgba16f rg32f rg16f r32f r16f rgba8 rgba16 r11f_g11f_b10f rgb10_a2ui
+    rgb10_a2i rg16 rg8 r16 r8 rgba32i rgba16i rgba8i rg32i rg16i rg8i r32i r16i r8i rgba32ui rgba16ui rgba8ui rg32ui rg16ui rg8ui
+    r32ui r16ui r8ui rgba16_snorm rgba8_snorm rg16_snorm rg8_snorm r16_snorm r8_snorm
 ]]
 
 -- keywords - shouldn't be left out
 for w in keyw:gmatch("([a-zA-Z_0-9]+)") do
-	api[w] = {type="keyword"}
+    api[w] = {type="keyword"}
 end
 
 return api

api/hlsl/dx11.lua

@@ -0,0 +1,60 @@
+-- authors: Luxinia Dev (Eike Decker & Christoph Kubisch)
+---------------------------------------------------------
+
+local function fn (description) 
+	local description2,returns,args = description:match("(.+)%-%s*(%b())%s*(%b())")
+	if not description2 then
+		return {type="function",description=description,
+			returns="(?)"} 
+	end
+	return {type="function",description=description2,
+		returns=returns:gsub("^%s+",""):gsub("%s+$",""), args = args} 
+end
+
+local api = {}
+
+local funcs = [[
+abs acos all AllMemoryBarrier AllMemoryBarrierWithGroupSync any asdouble asfloat asin asint asuint atan atan2 ceil clamp clip cos cosh countbits cross ddx ddx_coarse ddx_fine ddy ddy_coards ddy_fine degrees determinant DeviceMemoryBarrier DeviceMemoryBarrierWithGroupSync distance dot dst EvaluateAttributeAtCentroid EvaluateAttributeAtSample EvaluateAttributeSnapped exp exp2 f16tof32 f32tof16 faceforward firstbithigh firstbitlow floor fmod frac frexp fwidth GetRenderTargetSampleCount GetRenderTargetSamplePosition GroupMemoryBarrier GroupMemoryBarrierWithGroupSync InterlockedAdd InterlockedAnd InterlockedCompareExchange InterlockedExchange InterlockedMax InterlockedMin IntterlockedOr InterlockedXor isfinite isinf isnan ldexp length lerp lit log log10 log2 mad max min modf mul normalize pow Process2DQuadTessFactorsAvg Process2DQuadTessFactorsMax Process2DQuadTessFactorsMin ProcessIsolineTessFactors ProcessQuadTessFactorsAvg ProcessQuadTessFactorsMax ProcessQuadTessFactorsMin ProcessTriTessFactorsAvg ProcessTriTessFactorsMax ProcessTriTessFactorsMin radians rcp reflect refract reversebits round rsqrt saturate sign sin sincos sinh smoothstep sqrt step tan tanh transpose trunc
+]]
+
+for w in funcs:gmatch("([_%w]+)") do
+	api[w] = {type="function",returns="(?)"}
+end
+
+local objfuncs = [[
+Append RestartStrip CalculateLevelOfDetail CalculateLevelOfDetailUnclamped GetDimensions GetSamplePosition Load Sample SampleBias SampleCmp SampleCmpLevelZero SampleGrad SampleLevel Load2 Load3 Load4 Consume Store Store2 Store3 Store4 DecrementCounter IncrementCounter mips Gather GatherRed GatherGreen GatherBlue GatherAlpha GatherCmp GatherCmpRed GatherCmpGreen GatherCmpBlue GatherCmpAlpha
+]]
+
+for w in objfuncs:gmatch("([_%w]+)") do
+	api[w] = {type="function",returns="(?)"}
+end
+
+local keyw = 
+[[break continue if else switch return for while do typedef namespace true false compile
+    const void struct static extern register volatile inline target nointerpolation shared uniform row_major column_major snorm unorm 
+    bool bool1 bool2 bool3 bool4 int int1 int2 int3 int4 uint uint1 uint2 uint3 uint4 half half1 half2 half3 half4 float float1 float2 float3 float4 double double1 double2 double3 double4
+    matrix bool1x1 bool1x2 bool1x3 bool1x4 bool2x1 bool2x2 bool2x3 bool2x4 bool3x1 bool3x2 bool3x3 bool3x4 bool4x1 bool4x2 bool4x3 bool4x4
+    int1x1 int1x2 int1x3 int1x4 int2x1 int2x2 int2x3 int2x4 int3x1 int3x2 int3x3 int3x4 int4x1 int4x2 int4x3 int4x4 uint1x1 uint1x2 uint1x3 uint1x4 
+    uint2x1 uint2x2 uint2x3 uint2x4 uint3x1 uint3x2 uint3x3 uint3x4 uint4x1 uint4x2 uint4x3 uint4x4 half1x1 half1x2 half1x3 half1x4 half2x1 half2x2 
+    half2x3 half2x4 half3x1 half3x2 half3x3 half3x4 half4x1 half4x2 half4x3 half4x4 float1x1 float1x2 float1x3 float1x4 float2x1 float2x2 float2x3
+    float2x4 float3x1 float3x2 float3x3 float3x4 float4x1 float4x2 float4x3 float4x4 double1x1 double1x2 double1x3 double1x4 double2x1 double2x2 
+    double2x3 double2x4 double3x1 double3x2 double3x3 double3x4 double4x1 double4x2 double4x3 double4x4 cbuffer groupshared SamplerState 
+    in out inout vector matrix interface class point triangle line lineadj triangleadj
+    
+    Texture Texture1D Texture1DArray Texture2D Texture2DArray Texture2DMS Texture2DMSArray Texture3D TextureCube RWTexture1D RWTexture1DArray RWTexture2D RWTexture2DArray RWTexture3D 
+    Buffer StructuredBuffer AppendStructuredBuffer ConsumeStructuredBuffer RWBuffer RWStructuredBuffer ByteAddressBuffer RWByteAddressBuffer PointStream TriangleStream LineStream InputPatch OutputPatch
+    unroll loop flatten branch earlydepthstencil allow_uav_condition domain instance maxtessfactor outputcontrolpoints outputtopology partitioning patchconstantfunc numthreads maxvertexcount precise
+    
+    SV_DispatchThreadID SV_DomainLocation SV_GroupID SV_GroupIndex SV_GroupThreadID SV_GSInstanceID SV_InsideTessFactor SV_OutputControlPointID SV_Coverage SV_Depth SV_Position SV_IsFrontFace SV_RenderTargetArrayIndex SV_SampleIndex SV_ViewportArrayIndex SV_InstanceID SV_PrimitiveID SV_VertexID    
+    SV_ClipDistance SV_CullDistance SV_Target
+
+]]
+
+-- keywords - shouldn't be left out
+for w in keyw:gmatch("([_%w]+)") do
+	api[w] = {type="keyword"}
+end
+
+return api
+
+

api/lua/anttweakbar.lua

@@ -0,0 +1,553 @@
+--[[// tw tweakbar | AntTweakBar UI
+      enum { TW_VERSION = 114 }
+
+      typedef enum ETwType {
+	 TW_TYPE_UNDEF,
+	 TW_TYPE_BOOLCPP,
+	 TW_TYPE_BOOL8,
+	 TW_TYPE_BOOL16,
+	 TW_TYPE_BOOL32,
+	 TW_TYPE_CHAR,
+	 TW_TYPE_INT8,
+	 TW_TYPE_UINT8,
+	 TW_TYPE_INT16,
+	 TW_TYPE_UINT16,
+	 TW_TYPE_INT32,
+	 TW_TYPE_UINT32,
+	 TW_TYPE_FLOAT,
+	 TW_TYPE_DOUBLE,
+	 TW_TYPE_COLOR32,    // 32 bits color. Order is RGBA if API is OpenGL or Direct3D10, and inversed if API is Direct3D9 (can be modified by defining 'colorOrder=...', see doc)
+	 TW_TYPE_COLOR3F,    // 3 floats color. Order is RGB.
+	 TW_TYPE_COLOR4F,    // 4 floats color. Order is RGBA.
+	 TW_TYPE_CDSTRING,   // Null-terminated C Dynamic String (pointer to an array of char dynamically allocated with malloc/realloc/strdup)
+	 TW_TYPE__TEMP1,     // 
+	 TW_TYPE_QUAT4F,     // 4 floats encoding a quaternion {qx,qy,qz,qs}
+	 TW_TYPE_QUAT4D,     // 4 doubles encoding a quaternion {qx,qy,qz,qs}
+	 TW_TYPE_DIR3F,      // direction vector represented by 3 floats
+	 TW_TYPE_DIR3D,      // direction vector represented by 3 doubles
+	 TW_TYPE_CSSTRING_LEN0   = 0x30000000,
+	 TW_TYPE_CSSTRING_LEN256 = 0x30000000 + 256,
+      } TwType;
+
+      typedef struct CTwEnumVal  {
+	 int           Value;
+	 const char *  Label;
+      } TwEnumVal;
+
+      typedef struct CTwStructMember  {
+	 const char *  Name;
+	 TwType        Type;
+	 size_t        Offset;
+	 const char *  DefString;
+      } TwStructMember;
+      
+      typedef enum ETwParamValueType {
+	 TW_PARAM_INT32,
+	 TW_PARAM_FLOAT,
+	 TW_PARAM_DOUBLE,
+	 TW_PARAM_CSTRING // Null-terminated array of char (ie, c-string)
+      } TwParamValueType;
+      
+      typedef enum ETwGraphAPI {
+	 TW_OPENGL     = 1,
+	 TW_DIRECT3D9  = 2,
+	 TW_DIRECT3D10 = 3,
+	 TW_DIRECT3D11 = 4
+      } TwGraphAPI;
+      
+      typedef enum ETwKeyModifier {
+	 TW_KMOD_NONE  = 0x0000,   // same codes as SDL keysym.mod
+	 TW_KMOD_SHIFT = 0x0003,
+	 TW_KMOD_CTRL  = 0x00c0,
+	 TW_KMOD_ALT   = 0x0100,
+	 TW_KMOD_META  = 0x0c00
+      } TwKeyModifier;
+       
+      typedef enum EKeySpecial {
+	 TW_KEY_BACKSPACE  = '\b',
+	 TW_KEY_TAB        = '\t',
+	 TW_KEY_CLEAR      = 0x0c,
+	 TW_KEY_RETURN     = '\r',
+	 TW_KEY_PAUSE      = 0x13,
+	 TW_KEY_ESCAPE     = 0x1b,
+	 TW_KEY_SPACE      = ' ',
+	 TW_KEY_DELETE     = 0x7f,
+	 TW_KEY_UP         = 273,
+	 TW_KEY_DOWN,
+	 TW_KEY_RIGHT,
+	 TW_KEY_LEFT,
+	 TW_KEY_INSERT,
+	 TW_KEY_HOME,
+	 TW_KEY_END,
+	 TW_KEY_PAGE_UP,
+	 TW_KEY_PAGE_DOWN,
+	 TW_KEY_F1,
+	 TW_KEY_F2,
+	 TW_KEY_F3,
+	 TW_KEY_F4,
+	 TW_KEY_F5,
+	 TW_KEY_F6,
+	 TW_KEY_F7,
+	 TW_KEY_F8,
+	 TW_KEY_F9,
+	 TW_KEY_F10,
+	 TW_KEY_F11,
+	 TW_KEY_F12,
+	 TW_KEY_F13,
+	 TW_KEY_F14,
+	 TW_KEY_F15,
+	 TW_KEY_LAST
+      } TwKeySpecial;
+
+      typedef enum ETwMouseAction {
+	 TW_MOUSE_RELEASED,
+	 TW_MOUSE_PRESSED  
+      } TwMouseAction;
+      
+      typedef enum ETwMouseButtonID {
+	 TW_MOUSE_LEFT   = 1,
+	 TW_MOUSE_MIDDLE = 2,
+	 TW_MOUSE_RIGHT  = 3 
+      } TwMouseButtonID;
+
+      typedef void (*TwSetVarCallback)       ( const void *value, void *clientData );
+      typedef void (*TwGetVarCallback)       (       void *value, void *clientData );
+      typedef void (*TwButtonCallback)       (                    void *clientData );
+      typedef void (*TwSummaryCallback)      ( char *summaryString, size_t summaryMaxLength, const void *value, void *clientData );
+      typedef void (*TwCopyCDStringToClient) ( char **destinationClientStringPtr, const char *sourceString );
+      typedef void (*TwErrorHandler)         ( const char *errorMessage );
+      typedef void (*TwGLUTmousebuttonfun)   ( int glutButton, int glutState, int mouseX, int mouseY );
+      typedef void (*TwGLUTmousemotionfun)   ( int mouseX, int mouseY );
+      typedef void (*TwGLUTkeyboardfun)      ( unsigned char glutKey, int mouseX, int mouseY );
+      typedef void (*TwGLUTspecialfun)       ( int glutKey, int mouseX, int mouseY );
+      
+      typedef struct CTwBar TwBar;
+
+      TwBar*      TwNewBar(                    const char *barName );
+      int         TwDeleteBar(                 TwBar *bar          );
+      int         TwDeleteAllBars(                                 );
+      int         TwSetTopBar(                 const TwBar *bar    );
+      TwBar*      TwGetTopBar(                                     );
+      int         TwSetBottomBar(              const TwBar *bar    );
+      TwBar*      TwGetBottomBar(                                  );
+      const char* TwGetBarName(                TwBar *bar          );
+      int         TwGetBarCount(                                   );
+      TwBar*      TwGetBarByIndex(             int barIndex        );
+      TwBar*      TwGetBarByName(              const char *barName );
+      int         TwRefreshBar(                TwBar *bar          );
+      int         TwAddVarRW(                  TwBar *bar, const char *name, TwType type, void *var, const char *def );
+      int         TwAddVarRO(                  TwBar *bar, const char *name, TwType type, const void *var, const char *def );
+      int         TwAddVarCB(                  TwBar *bar, const char *name, TwType type, TwSetVarCallback setCallback, TwGetVarCallback getCallback, void *clientData, const char *def );
+      int         TwAddButton(                 TwBar *bar, const char *name, TwButtonCallback callback, void *clientData, const char *def );
+      int         TwAddSeparator(              TwBar *bar, const char *name, const char *def );
+      int         TwRemoveVar(                 TwBar *bar, const char *name );
+      int         TwRemoveAllVars(             TwBar *bar );
+      int         TwDefine(                    const char *def );
+      TwType      TwDefineEnum(                const char *name, const TwEnumVal *enumValues, unsigned int nbValues );
+      TwType      TwDefineEnumFromString(      const char *name, const char *enumString );
+      TwType      TwDefineStruct(              const char *name, const TwStructMember *structMembers, unsigned int nbMembers, size_t structSize, TwSummaryCallback summaryCallback, void *summaryClientData );
+      void        TwCopyCDStringToClientFunc(  TwCopyCDStringToClient copyCDStringFunc );
+      void        TwCopyCDStringToLibrary(     char **destinationLibraryStringPtr, const char *sourceClientString );
+      int         TwGetParam(                  TwBar *bar, const char *varName, const char *paramName, TwParamValueType paramValueType, unsigned int outValueMaxCount,      void *outValues );
+      int         TwSetParam(                  TwBar *bar, const char *varName, const char *paramName, TwParamValueType paramValueType, unsigned int     inValueCount, const void *inValues );
+      int         TwInit(                      TwGraphAPI graphAPI, void *device );
+      int         TwTerminate();
+      int         TwDraw();
+      int         TwWindowSize(                int width, int height);
+      int         TwSetCurrentWindow(          int windowID); // multi-windows support
+      int         TwGetCurrentWindow();
+      int         TwWindowExists(              int windowID);
+      int         TwKeyPressed(                int key, int modifiers);
+      int         TwKeyTest(                   int key, int modifiers);
+      int         TwMouseButton(               TwMouseAction action, TwMouseButtonID button);
+      int         TwMouseMotion(               int mouseX, int mouseY);
+      int         TwMouseWheel(                int pos);
+      const char* TwGetLastError(              );
+      void        TwHandleErrors(              TwErrorHandler errorHandler);
+      int         TwEventSDL(                  const void *sdlEvent, unsigned char sdlMajorVersion, unsigned char sdlMinorVersion);
+      int         TwEventSDL12(                const void *sdlEvent);
+      int         TwEventSDL13(                const void *sdlEvent);
+      int         TwEventMouseButtonGLFW(      int glfwButton, int glfwAction );
+      int         TwEventKeyGLFW(              int glfwKey,    int glfwAction );
+      int         TwEventCharGLFW(             int glfwChar,   int glfwAction );
+      int         TwEventMouseButtonGLUT(      int glutButton, int glutState, int mouseX, int mouseY);
+      int         TwEventMouseMotionGLUT(      int mouseX,     int mouseY);
+      int         TwEventKeyboardGLUT(         unsigned char glutKey, int mouseX, int mouseY );
+      int         TwEventSpecialGLUT(          int           glutKey, int mouseX, int mouseY );
+      int         TwGLUTModifiersFunc(         int (*glutGetModifiersFunc)(void) );
+      int         TwEventSFML(                 const void *sfmlEvent, unsigned char sfmlMajorVersion, unsigned char sfmlMinorVersion);
+]]
+  --auto-generated api from ffi headers
+  local api =
+         {
+         ["TW_TYPE_UNDEF"] = { type ='value', },
+       ["TW_TYPE_BOOLCPP"] = { type ='value', },
+       ["TW_TYPE_BOOL8"] = { type ='value', },
+       ["TW_TYPE_BOOL16"] = { type ='value', },
+       ["TW_TYPE_BOOL32"] = { type ='value', },
+       ["TW_TYPE_CHAR"] = { type ='value', },
+       ["TW_TYPE_INT8"] = { type ='value', },
+       ["TW_TYPE_UINT8"] = { type ='value', },
+       ["TW_TYPE_INT16"] = { type ='value', },
+       ["TW_TYPE_UINT16"] = { type ='value', },
+       ["TW_TYPE_INT32"] = { type ='value', },
+       ["TW_TYPE_UINT32"] = { type ='value', },
+       ["TW_TYPE_FLOAT"] = { type ='value', },
+       ["TW_TYPE_DOUBLE"] = { type ='value', },
+       ["TW_TYPE_COLOR32"] = { type ='value', },
+       ["TW_TYPE_COLOR3F"] = { type ='value', },
+       ["TW_TYPE_COLOR4F"] = { type ='value', },
+       ["TW_TYPE_CDSTRING"] = { type ='value', },
+       ["TW_TYPE__TEMP1"] = { type ='value', },
+       ["TW_TYPE_QUAT4F"] = { type ='value', },
+       ["TW_TYPE_QUAT4D"] = { type ='value', },
+       ["TW_TYPE_DIR3F"] = { type ='value', },
+       ["TW_TYPE_DIR3D"] = { type ='value', },
+       ["TW_TYPE_CSSTRING_LEN0"] = { type ='value', },
+       ["TW_TYPE_CSSTRING_LEN256"] = { type ='value', },
+       ["TW_PARAM_INT32"] = { type ='value', },
+       ["TW_PARAM_FLOAT"] = { type ='value', },
+       ["TW_PARAM_DOUBLE"] = { type ='value', },
+       ["TW_PARAM_CSTRING"] = { type ='value', },
+       ["TW_OPENGL"] = { type ='value', },
+       ["TW_DIRECT3D9"] = { type ='value', },
+       ["TW_DIRECT3D10"] = { type ='value', },
+       ["TW_DIRECT3D11"] = { type ='value', },
+       ["TW_KMOD_NONE"] = { type ='value', },
+       ["TW_KMOD_SHIFT"] = { type ='value', },
+       ["TW_KMOD_CTRL"] = { type ='value', },
+       ["TW_KMOD_ALT"] = { type ='value', },
+       ["TW_KMOD_META"] = { type ='value', },
+       ["TW_KEY_BACKSPACE"] = { type ='value', },
+       ["TW_KEY_TAB"] = { type ='value', },
+       ["TW_KEY_CLEAR"] = { type ='value', },
+       ["TW_KEY_RETURN"] = { type ='value', },
+       ["TW_KEY_PAUSE"] = { type ='value', },
+       ["TW_KEY_ESCAPE"] = { type ='value', },
+       ["TW_KEY_SPACE"] = { type ='value', },
+       ["TW_KEY_DELETE"] = { type ='value', },
+       ["TW_KEY_UP"] = { type ='value', },
+       ["TW_KEY_DOWN"] = { type ='value', },
+       ["TW_KEY_RIGHT"] = { type ='value', },
+       ["TW_KEY_LEFT"] = { type ='value', },
+       ["TW_KEY_INSERT"] = { type ='value', },
+       ["TW_KEY_HOME"] = { type ='value', },
+       ["TW_KEY_END"] = { type ='value', },
+       ["TW_KEY_PAGE_UP"] = { type ='value', },
+       ["TW_KEY_PAGE_DOWN"] = { type ='value', },
+       ["TW_KEY_F1"] = { type ='value', },
+       ["TW_KEY_F2"] = { type ='value', },
+       ["TW_KEY_F3"] = { type ='value', },
+       ["TW_KEY_F4"] = { type ='value', },
+       ["TW_KEY_F5"] = { type ='value', },
+       ["TW_KEY_F6"] = { type ='value', },
+       ["TW_KEY_F7"] = { type ='value', },
+       ["TW_KEY_F8"] = { type ='value', },
+       ["TW_KEY_F9"] = { type ='value', },
+       ["TW_KEY_F10"] = { type ='value', },
+       ["TW_KEY_F11"] = { type ='value', },
+       ["TW_KEY_F12"] = { type ='value', },
+       ["TW_KEY_F13"] = { type ='value', },
+       ["TW_KEY_F14"] = { type ='value', },
+       ["TW_KEY_F15"] = { type ='value', },
+       ["TW_KEY_LAST"] = { type ='value', },
+       ["TW_MOUSE_RELEASED"] = { type ='value', },
+       ["TW_MOUSE_PRESSED"] = { type ='value', },
+       ["TW_MOUSE_LEFT"] = { type ='value', },
+       ["TW_MOUSE_MIDDLE"] = { type ='value', },
+       ["TW_MOUSE_RIGHT"] = { type ='value', },
+       ["TwNewBar"] = { type ='function',
+          description = "",
+          returns = "(TwBar*)",
+          valuetype = nil,
+          args = "(const char *barName)", },
+       ["TwDeleteBar"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(TwBar *bar)", },
+       ["TwDeleteAllBars"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "()", },
+       ["TwSetTopBar"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(const TwBar *bar)", },
+       ["TwGetTopBar"] = { type ='function',
+          description = "",
+          returns = "(TwBar*)",
+          valuetype = nil,
+          args = "()", },
+       ["TwSetBottomBar"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(const TwBar *bar)", },
+       ["TwGetBottomBar"] = { type ='function',
+          description = "",
+          returns = "(TwBar*)",
+          valuetype = nil,
+          args = "()", },
+       ["TwGetBarName"] = { type ='function',
+          description = "",
+          returns = "(const char*)",
+          valuetype = "string",
+          args = "(TwBar *bar)", },
+       ["TwGetBarCount"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "()", },
+       ["TwGetBarByIndex"] = { type ='function',
+          description = "",
+          returns = "(TwBar*)",
+          valuetype = nil,
+          args = "(int barIndex)", },
+       ["TwGetBarByName"] = { type ='function',
+          description = "",
+          returns = "(TwBar*)",
+          valuetype = nil,
+          args = "(const char *barName)", },
+       ["TwRefreshBar"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(TwBar *bar)", },
+       ["TwAddVarRW"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(TwBar *bar, const char *name, TwType type, void *var, const char *def)", },
+       ["TwAddVarRO"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(TwBar *bar, const char *name, TwType type, const void *var, const char *def)", },
+       ["TwAddVarCB"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(TwBar *bar, const char *name, TwType type, TwSetVarCallback setCallback, TwGetVarCallback getCallback, void *clientData, const char *def)", },
+       ["TwAddButton"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(TwBar *bar, const char *name, TwButtonCallback callback, void *clientData, const char *def)", },
+       ["TwAddSeparator"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(TwBar *bar, const char *name, const char *def)", },
+       ["TwRemoveVar"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(TwBar *bar, const char *name)", },
+       ["TwRemoveAllVars"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(TwBar *bar)", },
+       ["TwDefine"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(const char *def)", },
+       ["TwDefineEnum"] = { type ='function',
+          description = "",
+          returns = "(TwType)",
+          valuetype = nil,
+          args = "(const char *name, const TwEnumVal *enumValues, unsigned int nbValues)", },
+       ["TwDefineEnumFromString"] = { type ='function',
+          description = "",
+          returns = "(TwType)",
+          valuetype = nil,
+          args = "(const char *name, const char *enumString)", },
+       ["TwDefineStruct"] = { type ='function',
+          description = "",
+          returns = "(TwType)",
+          valuetype = nil,
+          args = "(const char *name, const TwStructMember *structMembers, unsigned int nbMembers, size_t structSize, TwSummaryCallback summaryCallback, void *summaryClientData)", },
+       ["TwCopyCDStringToClientFunc"] = { type ='function',
+          description = "",
+          returns = "(void)",
+          valuetype = nil,
+          args = "(TwCopyCDStringToClient copyCDStringFunc)", },
+       ["TwCopyCDStringToLibrary"] = { type ='function',
+          description = "",
+          returns = "(void)",
+          valuetype = nil,
+          args = "(char **destinationLibraryStringPtr, const char *sourceClientString)", },
+       ["TwGetParam"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(TwBar *bar, const char *varName, const char *paramName, TwParamValueType paramValueType, unsigned int outValueMaxCount,      void *outValues)", },
+       ["TwSetParam"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(TwBar *bar, const char *varName, const char *paramName, TwParamValueType paramValueType, unsigned int     inValueCount, const void *inValues)", },
+       ["TwInit"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(TwGraphAPI graphAPI, void *device)", },
+       ["TwTerminate"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "()", },
+       ["TwDraw"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "()", },
+       ["TwWindowSize"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(int width, int height)", },
+       ["TwSetCurrentWindow"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(int windowID)", },
+       ["TwGetCurrentWindow"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "()", },
+       ["TwWindowExists"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(int windowID)", },
+       ["TwKeyPressed"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(int key, int modifiers)", },
+       ["TwKeyTest"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(int key, int modifiers)", },
+       ["TwMouseButton"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(TwMouseAction action, TwMouseButtonID button)", },
+       ["TwMouseMotion"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(int mouseX, int mouseY)", },
+       ["TwMouseWheel"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(int pos)", },
+       ["TwGetLastError"] = { type ='function',
+          description = "",
+          returns = "(const char*)",
+          valuetype = "string",
+          args = "()", },
+       ["TwHandleErrors"] = { type ='function',
+          description = "",
+          returns = "(void)",
+          valuetype = nil,
+          args = "(TwErrorHandler errorHandler)", },
+       ["TwEventSDL"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(const void *sdlEvent, unsigned char sdlMajorVersion, unsigned char sdlMinorVersion)", },
+       ["TwEventSDL12"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(const void *sdlEvent)", },
+       ["TwEventSDL13"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(const void *sdlEvent)", },
+       ["TwEventMouseButtonGLFW"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(int glfwButton, int glfwAction)", },
+       ["TwEventKeyGLFW"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(int glfwKey,    int glfwAction)", },
+       ["TwEventCharGLFW"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(int glfwChar,   int glfwAction)", },
+       ["TwEventMouseButtonGLUT"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(int glutButton, int glutState, int mouseX, int mouseY)", },
+       ["TwEventMouseMotionGLUT"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(int mouseX,     int mouseY)", },
+       ["TwEventKeyboardGLUT"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(unsigned char glutKey, int mouseX, int mouseY)", },
+       ["TwEventSpecialGLUT"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(int           glutKey, int mouseX, int mouseY)", },
+       ["glutGetModifiersFunc"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(void))", },
+       ["TwEventSFML"] = { type ='function',
+          description = "",
+          returns = "(int)",
+          valuetype = nil,
+          args = "(const void *sfmlEvent, unsigned char sfmlMajorVersion, unsigned char sfmlMinorVersion)", },
+       ["TwEnumVal"] = { type ='class',
+          description = "",
+          childs =         {
+          ["Value"] = { type ='value', description = "int          ", valuetype = nil, },
+        ["Label"] = { type ='value', description = "const char * ", valuetype = "string", },
+                }
+         },
+       ["TwStructMember"] = { type ='class',
+          description = "",
+          childs =         {
+          ["Name"] = { type ='value', description = "const char * ", valuetype = "string", },
+        ["Type"] = { type ='value', description = "TwType       ", valuetype = nil, },
+        ["Offset"] = { type ='value', description = "size_t       ", valuetype = nil, },
+        ["DefString"] = { type ='value', description = "const char * ", valuetype = "string", },
+                }
+         },
+               }
+  return {
+        tw = {
+      type = 'lib',
+      description = "AntTweakBar UI",
+      childs = api,
+    },
+        tweakbar = {
+      type = 'lib',
+      description = "AntTweakBar UI",
+      childs = api,
+    },
+      }
+  

api/lua/cggl30.lua

@@ -1,572 +0,0 @@
---[[// cggl cgGL | Cg OpenGL runtime
-typedef unsigned int GLuint;
-typedef unsigned int GLenum;
-typedef void GLvoid;
-typedef int GLsizei;
-typedef int GLint;
-
-typedef enum
-{
-  CG_GL_MATRIX_IDENTITY             = 0,
-  CG_GL_MATRIX_TRANSPOSE            = 1,
-  CG_GL_MATRIX_INVERSE              = 2,
-  CG_GL_MATRIX_INVERSE_TRANSPOSE    = 3,
-  CG_GL_MODELVIEW_MATRIX            = 4,
-  CG_GL_PROJECTION_MATRIX           = 5,
-  CG_GL_TEXTURE_MATRIX              = 6,
-  CG_GL_MODELVIEW_PROJECTION_MATRIX = 7,
-  CG_GL_VERTEX                      = 8,
-  CG_GL_FRAGMENT                    = 9,
-  CG_GL_GEOMETRY                    = 10,
-  CG_GL_TESSELLATION_CONTROL        = 11,
-  CG_GL_TESSELLATION_EVALUATION     = 12
-} CGGLenum;
-
- CGbool  cgGLIsProfileSupported(CGprofile profile);
- void  cgGLEnableProfile(CGprofile profile);
- void  cgGLDisableProfile(CGprofile profile);
- CGprofile  cgGLGetLatestProfile(CGGLenum profile_type);
- void  cgGLSetOptimalOptions(CGprofile profile);
- char const **  cgGLGetOptimalOptions(CGprofile profile);
- void  cgGLLoadProgram(CGprogram program);
- void  cgGLUnloadProgram(CGprogram program);
- CGbool  cgGLIsProgramLoaded(CGprogram program);
- void  cgGLBindProgram(CGprogram program);
- void  cgGLUnbindProgram(CGprofile profile);
- GLuint  cgGLGetProgramID(CGprogram program);
- void  cgGLSetParameter1f(CGparameter param, float x);
- void  cgGLSetParameter2f(CGparameter param, float x, float y);
- void  cgGLSetParameter3f(CGparameter param, float x, float y, float z);
- void  cgGLSetParameter4f(CGparameter param, float x, float y, float z, float w);
- void  cgGLSetParameter1fv(CGparameter param, const float *v);
- void  cgGLSetParameter2fv(CGparameter param, const float *v);
- void  cgGLSetParameter3fv(CGparameter param, const float *v);
- void  cgGLSetParameter4fv(CGparameter param, const float *v);
- void  cgGLSetParameter1d(CGparameter param, double x);
- void  cgGLSetParameter2d(CGparameter param, double x, double y);
- void  cgGLSetParameter3d(CGparameter param, double x, double y, double z);
- void  cgGLSetParameter4d(CGparameter param, double x, double y, double z, double w);
- void  cgGLSetParameter1dv(CGparameter param, const double *v);
- void  cgGLSetParameter2dv(CGparameter param, const double *v);
- void  cgGLSetParameter3dv(CGparameter param, const double *v);
- void  cgGLSetParameter4dv(CGparameter param, const double *v);
- void  cgGLGetParameter1f(CGparameter param, float *v);
- void  cgGLGetParameter2f(CGparameter param, float *v);
- void  cgGLGetParameter3f(CGparameter param, float *v);
- void  cgGLGetParameter4f(CGparameter param, float *v);
- void  cgGLGetParameter1d(CGparameter param, double *v);
- void  cgGLGetParameter2d(CGparameter param, double *v);
- void  cgGLGetParameter3d(CGparameter param, double *v);
- void  cgGLGetParameter4d(CGparameter param, double *v);
- void  cgGLSetParameterArray1f(CGparameter param, long offset, long nelements, const float *v);
- void  cgGLSetParameterArray2f(CGparameter param, long offset, long nelements, const float *v);
- void  cgGLSetParameterArray3f(CGparameter param, long offset, long nelements, const float *v);
- void  cgGLSetParameterArray4f(CGparameter param, long offset, long nelements, const float *v);
- void  cgGLSetParameterArray1d(CGparameter param, long offset, long nelements, const double *v);
- void  cgGLSetParameterArray2d(CGparameter param, long offset, long nelements, const double *v);
- void  cgGLSetParameterArray3d(CGparameter param, long offset, long nelements, const double *v);
- void  cgGLSetParameterArray4d(CGparameter param, long offset, long nelements, const double *v);
- void  cgGLGetParameterArray1f(CGparameter param, long offset, long nelements, float *v);
- void  cgGLGetParameterArray2f(CGparameter param, long offset, long nelements, float *v);
- void  cgGLGetParameterArray3f(CGparameter param, long offset, long nelements, float *v);
- void  cgGLGetParameterArray4f(CGparameter param, long offset, long nelements, float *v);
- void  cgGLGetParameterArray1d(CGparameter param, long offset, long nelements, double *v);
- void  cgGLGetParameterArray2d(CGparameter param, long offset, long nelements, double *v);
- void  cgGLGetParameterArray3d(CGparameter param, long offset, long nelements, double *v);
- void  cgGLGetParameterArray4d(CGparameter param, long offset, long nelements, double *v);
- void  cgGLSetParameterPointer(CGparameter param, GLint fsize, GLenum type, GLsizei stride, const GLvoid *pointer);
- void  cgGLEnableClientState(CGparameter param);
- void  cgGLDisableClientState(CGparameter param);
- void  cgGLSetMatrixParameterdr(CGparameter param, const double *matrix);
- void  cgGLSetMatrixParameterfr(CGparameter param, const float *matrix);
- void  cgGLSetMatrixParameterdc(CGparameter param, const double *matrix);
- void  cgGLSetMatrixParameterfc(CGparameter param, const float *matrix);
- void  cgGLGetMatrixParameterdr(CGparameter param, double *matrix);
- void  cgGLGetMatrixParameterfr(CGparameter param, float *matrix);
- void  cgGLGetMatrixParameterdc(CGparameter param, double *matrix);
- void  cgGLGetMatrixParameterfc(CGparameter param, float *matrix);
- void  cgGLSetStateMatrixParameter(CGparameter param, CGGLenum matrix, CGGLenum transform);
- void  cgGLSetMatrixParameterArrayfc(CGparameter param, long offset, long nelements, const float *matrices);
- void  cgGLSetMatrixParameterArrayfr(CGparameter param, long offset, long nelements, const float *matrices);
- void  cgGLSetMatrixParameterArraydc(CGparameter param, long offset, long nelements, const double *matrices);
- void  cgGLSetMatrixParameterArraydr(CGparameter param, long offset, long nelements, const double *matrices);
- void  cgGLGetMatrixParameterArrayfc(CGparameter param, long offset, long nelements, float *matrices);
- void  cgGLGetMatrixParameterArrayfr(CGparameter param, long offset, long nelements, float *matrices);
- void  cgGLGetMatrixParameterArraydc(CGparameter param, long offset, long nelements, double *matrices);
- void  cgGLGetMatrixParameterArraydr(CGparameter param, long offset, long nelements, double *matrices);
- void  cgGLSetTextureParameter(CGparameter param, GLuint texobj);
- GLuint  cgGLGetTextureParameter(CGparameter param);
- void  cgGLEnableTextureParameter(CGparameter param);
- void  cgGLDisableTextureParameter(CGparameter param);
- GLenum  cgGLGetTextureEnum(CGparameter param);
- void  cgGLSetManageTextureParameters(CGcontext ctx, CGbool flag);
- CGbool  cgGLGetManageTextureParameters(CGcontext ctx);
- void  cgGLSetupSampler(CGparameter param, GLuint texobj);
- void  cgGLRegisterStates(CGcontext ctx);
- void  cgGLEnableProgramProfiles(CGprogram program);
- void  cgGLDisableProgramProfiles(CGprogram program);
- void  cgGLSetDebugMode(CGbool debug);
- CGbuffer  cgGLCreateBuffer(CGcontext context, int size, const void *data, GLenum bufferUsage);
- GLuint  cgGLGetBufferObject(CGbuffer buffer);
-
-]]  
---auto-generated api from ffi headers
-local api =
-  {
-  ["CGGLenum"] = { type ='value', description = "", valuetype = nil, },
-  ["CG_GL_MATRIX_IDENTITY"] = { type ='value', },
-  ["CG_GL_MATRIX_TRANSPOSE"] = { type ='value', },
-  ["CG_GL_MATRIX_INVERSE"] = { type ='value', },
-  ["CG_GL_MATRIX_INVERSE_TRANSPOSE"] = { type ='value', },
-  ["CG_GL_MODELVIEW_MATRIX"] = { type ='value', },
-  ["CG_GL_PROJECTION_MATRIX"] = { type ='value', },
-  ["CG_GL_TEXTURE_MATRIX"] = { type ='value', },
-  ["CG_GL_MODELVIEW_PROJECTION_MATRIX"] = { type ='value', },
-  ["CG_GL_VERTEX"] = { type ='value', },
-  ["CG_GL_FRAGMENT"] = { type ='value', },
-  ["CG_GL_GEOMETRY"] = { type ='value', },
-  ["CG_GL_TESSELLATION_CONTROL"] = { type ='value', },
-  ["CG_GL_TESSELLATION_EVALUATION"] = { type ='value', },
-  ["cgGLIsProfileSupported"] = { type ='function', 
-    description = "", 
-    returns = "(CGbool)",
-    valuetype = nil,
-    args = "(CGprofile profile)", },
-  ["cgGLEnableProfile"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGprofile profile)", },
-  ["cgGLDisableProfile"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGprofile profile)", },
-  ["cgGLGetLatestProfile"] = { type ='function', 
-    description = "", 
-    returns = "(CGprofile)",
-    valuetype = nil,
-    args = "(CGGLenum profile_type)", },
-  ["cgGLSetOptimalOptions"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGprofile profile)", },
-  ["cgGLGetOptimalOptions"] = { type ='function', 
-    description = "", 
-    returns = "(char const **)",
-    valuetype = nil,
-    args = "(CGprofile profile)", },
-  ["cgGLLoadProgram"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGprogram program)", },
-  ["cgGLUnloadProgram"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGprogram program)", },
-  ["cgGLIsProgramLoaded"] = { type ='function', 
-    description = "", 
-    returns = "(CGbool)",
-    valuetype = nil,
-    args = "(CGprogram program)", },
-  ["cgGLBindProgram"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGprogram program)", },
-  ["cgGLUnbindProgram"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGprofile profile)", },
-  ["cgGLGetProgramID"] = { type ='function', 
-    description = "", 
-    returns = "(GLuint)",
-    valuetype = nil,
-    args = "(CGprogram program)", },
-  ["cgGLSetParameter1f"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, float x)", },
-  ["cgGLSetParameter2f"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, float x, float y)", },
-  ["cgGLSetParameter3f"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, float x, float y, float z)", },
-  ["cgGLSetParameter4f"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, float x, float y, float z, float w)", },
-  ["cgGLSetParameter1fv"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, const float *v)", },
-  ["cgGLSetParameter2fv"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, const float *v)", },
-  ["cgGLSetParameter3fv"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, const float *v)", },
-  ["cgGLSetParameter4fv"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, const float *v)", },
-  ["cgGLSetParameter1d"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, double x)", },
-  ["cgGLSetParameter2d"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, double x, double y)", },
-  ["cgGLSetParameter3d"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, double x, double y, double z)", },
-  ["cgGLSetParameter4d"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, double x, double y, double z, double w)", },
-  ["cgGLSetParameter1dv"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, const double *v)", },
-  ["cgGLSetParameter2dv"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, const double *v)", },
-  ["cgGLSetParameter3dv"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, const double *v)", },
-  ["cgGLSetParameter4dv"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, const double *v)", },
-  ["cgGLGetParameter1f"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, float *v)", },
-  ["cgGLGetParameter2f"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, float *v)", },
-  ["cgGLGetParameter3f"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, float *v)", },
-  ["cgGLGetParameter4f"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, float *v)", },
-  ["cgGLGetParameter1d"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, double *v)", },
-  ["cgGLGetParameter2d"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, double *v)", },
-  ["cgGLGetParameter3d"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, double *v)", },
-  ["cgGLGetParameter4d"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, double *v)", },
-  ["cgGLSetParameterArray1f"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, long offset, long nelements, const float *v)", },
-  ["cgGLSetParameterArray2f"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, long offset, long nelements, const float *v)", },
-  ["cgGLSetParameterArray3f"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, long offset, long nelements, const float *v)", },
-  ["cgGLSetParameterArray4f"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, long offset, long nelements, const float *v)", },
-  ["cgGLSetParameterArray1d"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, long offset, long nelements, const double *v)", },
-  ["cgGLSetParameterArray2d"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, long offset, long nelements, const double *v)", },
-  ["cgGLSetParameterArray3d"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, long offset, long nelements, const double *v)", },
-  ["cgGLSetParameterArray4d"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, long offset, long nelements, const double *v)", },
-  ["cgGLGetParameterArray1f"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, long offset, long nelements, float *v)", },
-  ["cgGLGetParameterArray2f"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, long offset, long nelements, float *v)", },
-  ["cgGLGetParameterArray3f"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, long offset, long nelements, float *v)", },
-  ["cgGLGetParameterArray4f"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, long offset, long nelements, float *v)", },
-  ["cgGLGetParameterArray1d"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, long offset, long nelements, double *v)", },
-  ["cgGLGetParameterArray2d"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, long offset, long nelements, double *v)", },
-  ["cgGLGetParameterArray3d"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, long offset, long nelements, double *v)", },
-  ["cgGLGetParameterArray4d"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, long offset, long nelements, double *v)", },
-  ["cgGLSetParameterPointer"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, GLint fsize, GLenum type, GLsizei stride, const GLvoid *pointer)", },
-  ["cgGLEnableClientState"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param)", },
-  ["cgGLDisableClientState"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param)", },
-  ["cgGLSetMatrixParameterdr"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, const double *matrix)", },
-  ["cgGLSetMatrixParameterfr"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, const float *matrix)", },
-  ["cgGLSetMatrixParameterdc"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, const double *matrix)", },
-  ["cgGLSetMatrixParameterfc"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, const float *matrix)", },
-  ["cgGLGetMatrixParameterdr"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, double *matrix)", },
-  ["cgGLGetMatrixParameterfr"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, float *matrix)", },
-  ["cgGLGetMatrixParameterdc"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, double *matrix)", },
-  ["cgGLGetMatrixParameterfc"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, float *matrix)", },
-  ["cgGLSetStateMatrixParameter"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, CGGLenum matrix, CGGLenum transform)", },
-  ["cgGLSetMatrixParameterArrayfc"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, long offset, long nelements, const float *matrices)", },
-  ["cgGLSetMatrixParameterArrayfr"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, long offset, long nelements, const float *matrices)", },
-  ["cgGLSetMatrixParameterArraydc"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, long offset, long nelements, const double *matrices)", },
-  ["cgGLSetMatrixParameterArraydr"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, long offset, long nelements, const double *matrices)", },
-  ["cgGLGetMatrixParameterArrayfc"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, long offset, long nelements, float *matrices)", },
-  ["cgGLGetMatrixParameterArrayfr"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, long offset, long nelements, float *matrices)", },
-  ["cgGLGetMatrixParameterArraydc"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, long offset, long nelements, double *matrices)", },
-  ["cgGLGetMatrixParameterArraydr"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, long offset, long nelements, double *matrices)", },
-  ["cgGLSetTextureParameter"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, GLuint texobj)", },
-  ["cgGLGetTextureParameter"] = { type ='function', 
-    description = "", 
-    returns = "(GLuint)",
-    valuetype = nil,
-    args = "(CGparameter param)", },
-  ["cgGLEnableTextureParameter"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param)", },
-  ["cgGLDisableTextureParameter"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param)", },
-  ["cgGLGetTextureEnum"] = { type ='function', 
-    description = "", 
-    returns = "(GLenum)",
-    valuetype = nil,
-    args = "(CGparameter param)", },
-  ["cgGLSetManageTextureParameters"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGcontext ctx, CGbool flag)", },
-  ["cgGLGetManageTextureParameters"] = { type ='function', 
-    description = "", 
-    returns = "(CGbool)",
-    valuetype = nil,
-    args = "(CGcontext ctx)", },
-  ["cgGLSetupSampler"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGparameter param, GLuint texobj)", },
-  ["cgGLRegisterStates"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGcontext ctx)", },
-  ["cgGLEnableProgramProfiles"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGprogram program)", },
-  ["cgGLDisableProgramProfiles"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGprogram program)", },
-  ["cgGLSetDebugMode"] = { type ='function', 
-    description = "", 
-    returns = "(void)",
-    valuetype = nil,
-    args = "(CGbool debug)", },
-  ["cgGLCreateBuffer"] = { type ='function', 
-    description = "", 
-    returns = "(CGbuffer)",
-    valuetype = nil,
-    args = "(CGcontext context, int size, const void *data, GLenum bufferUsage)", },
-  ["cgGLGetBufferObject"] = { type ='function', 
-    description = "", 
-    returns = "(GLuint)",
-    valuetype = nil,
-    args = "(CGbuffer buffer)", },
-  }
-return {
-  cggl = {
-    type = 'lib',
-    description = "Cg OpenGL runtime",
-    childs = api,
-  },
-  cgGL = {
-    type = 'lib',
-    description = "Cg OpenGL runtime",
-    childs = api,
-  },
-}

api/lua/cudagl32.lua

@@ -1,79 +0,0 @@
---[[// cugl cuGL | Cuda GL Interop
-/*
- * Copyright 1993-2010 NVIDIA Corporation.  All rights reserved.
- *
- * NOTICE TO USER:   
- *
- * This source code is subject to NVIDIA ownership rights under U.S. and 
- * international Copyright laws.  Users and possessors of this source code 
- * are hereby granted a nonexclusive, royalty-free license to use this code 
- * in individual and commercial software.
- *
- * NVIDIA MAKES NO REPRESENTATION ABOUT THE SUITABILITY OF THIS SOURCE 
- * CODE FOR ANY PURPOSE.  IT IS PROVIDED "AS IS" WITHOUT EXPRESS OR 
- * IMPLIED WARRANTY OF ANY KIND.  NVIDIA DISCLAIMS ALL WARRANTIES WITH 
- * REGARD TO THIS SOURCE CODE, INCLUDING ALL IMPLIED WARRANTIES OF 
- * MERCHANTABILITY, NONINFRINGEMENT, AND FITNESS FOR A PARTICULAR PURPOSE.
- * IN NO EVENT SHALL NVIDIA BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL, 
- * OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS 
- * OF USE, DATA OR PROFITS,  WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE 
- * OR OTHER TORTIOUS ACTION,  ARISING OUT OF OR IN CONNECTION WITH THE USE 
- * OR PERFORMANCE OF THIS SOURCE CODE.  
- *
- * U.S. Government End Users.   This source code is a "commercial item" as 
- * that term is defined at  48 C.F.R. 2.101 (OCT 1995), consisting  of 
- * "commercial computer  software"  and "commercial computer software 
- * documentation" as such terms are  used in 48 C.F.R. 12.212 (SEPT 1995) 
- * and is provided to the U.S. Government only as a commercial end item.  
- * Consistent with 48 C.F.R.12.212 and 48 C.F.R. 227.7202-1 through 
- * 227.7202-4 (JUNE 1995), all U.S. Government End Users acquire the 
- * source code with only those rights set forth herein. 
- *
- * Any use of this source code in individual and commercial software must 
- * include, in the user documentation and internal comments to the code,
- * the above Disclaimer and U.S. Government End Users Notice.
- */
-
-CUresult cuGLCtxCreate_v2(CUcontext *pCtx, unsigned int Flags, CUdevice device );
-CUresult cuGraphicsGLRegisterBuffer(CUgraphicsResource *pCudaResource, GLuint buffer, unsigned int Flags);
-CUresult cuGraphicsGLRegisterImage(CUgraphicsResource *pCudaResource, GLuint image, GLenum target, unsigned int Flags);
-
-typedef void* HGPUNV;
-CUresult cuWGLGetDevice(CUdevice *pDevice, HGPUNV hGpu);
-]]  
---auto-generated api from ffi headers
-local api =
-  {
-  ["cuGLCtxCreate_v2"] = { type ='function', 
-    description = "", 
-    returns = "(CUresult)",
-    valuetype = nil,
-    args = "(CUcontext *pCtx, unsigned int Flags, CUdevice device)", },
-  ["cuGraphicsGLRegisterBuffer"] = { type ='function', 
-    description = "", 
-    returns = "(CUresult)",
-    valuetype = nil,
-    args = "(CUgraphicsResource *pCudaResource, GLuint buffer, unsigned int Flags)", },
-  ["cuGraphicsGLRegisterImage"] = { type ='function', 
-    description = "", 
-    returns = "(CUresult)",
-    valuetype = nil,
-    args = "(CUgraphicsResource *pCudaResource, GLuint image, GLenum target, unsigned int Flags)", },
-  ["cuWGLGetDevice"] = { type ='function', 
-    description = "", 
-    returns = "(CUresult)",
-    valuetype = nil,
-    args = "(CUdevice *pDevice, HGPUNV hGpu)", },
-  }
-return {
-  cugl = {
-    type = 'lib',
-    description = "Cuda GL Interop",
-    childs = api,
-  },
-  cuGL = {
-    type = 'lib',
-    description = "Cuda GL Interop",
-    childs = api,
-  },
-}

api/lua/love2d.lua

@@ -1,12 +1,37 @@
+-- Copyright 2011-12 Paul Kulchenko, ZeroBrane LLC
+
 -- converted from love_api.lua (https://love2d.org/forums/viewtopic.php?f=3&t=1796&start=30)
+-- (as of Nov 1, 2012)
 -- the conversion script is at the bottom of this file
--- there were several manual changes done to the "thread" methods that had
--- incorrect structure (demand, set, and few others)
+-- manually removed "linear clamped", "exponent clamped", and "inverse clamped"
+-- values as those can't be entered through auto-complete.
 
 local love = {
  childs = {
   audio = {
    childs = {
+    DistanceModel = {
+     childs = {
+      exponent = {
+       description = "Exponential attenuation.",
+       type = "value"
+      },
+      inverse = {
+       description = "Inverse distance attenuation.",
+       type = "value"
+      },
+      linear = {
+       description = "Linear attenuation.",
+       type = "value"
+      },
+      none = {
+       description = "Sources do not get attenuated.",
+       type = "value"
+      }
+     },
+     description = "class constants",
+     type = "class"
+    },
     Source = {
      childs = {
       getDirection = {
@@ -18,7 +43,7 @@ local love = {
       getDistance = {
        args = "()",
        description = "Returns the reference and maximum distance of the source.",
-       returns = "(ref: string, max: string)",
+       returns = "(ref: number, max: number)",
        type = "function"
       },
       getPitch = {
@@ -33,6 +58,12 @@ local love = {
        returns = "(x: number, y: number, z: number)",
        type = "function"
       },
+      getRolloff = {
+       args = "()",
+       description = "Returns the rolloff factor of the source.",
+       returns = "(rolloff: number)",
+       type = "function"
+      },
       getVelocity = {
        args = "()",
        description = "Gets the velocity of the Source.",
@@ -45,6 +76,12 @@ local love = {
        returns = "(volume: number)",
        type = "function"
       },
+      getVolumeLimits = {
+       args = "()",
+       description = "Returns the volume limits of the source.",
+       returns = "(min: number, max: number)",
+       type = "function"
+      },
       isLooping = {
        args = "()",
        description = "Returns whether the Source will loop.",
@@ -105,6 +142,12 @@ local love = {
        returns = "()",
        type = "function"
       },
+      setDistance = {
+       args = "(ref: number, max: number)",
+       description = "Sets the reference and maximum distance of the source.",
+       returns = "()",
+       type = "function"
+      },
       setLooping = {
        args = "(loop: boolean)",
        description = "Sets whether the Source should loop.",
@@ -123,6 +166,12 @@ local love = {
        returns = "()",
        type = "function"
       },
+      setRolloff = {
+       args = "(rolloff: number)",
+       description = "Sets the rolloff factor.",
+       returns = "()",
+       type = "function"
+      },
       setVelocity = {
        args = "(x: number, y: number, z: number)",
        description = "Sets the velocity of the Source.\n\nThis does not change the position of the Source, but lets the application know how it has to calculate the doppler effect.",
@@ -135,6 +184,12 @@ local love = {
        returns = "()",
        type = "function"
       },
+      setVolumeLimits = {
+       args = "(min: number, max: number)",
+       description = "Sets the volume limits of the source. The limits have to be numbers from 0 to 1.",
+       returns = "()",
+       type = "function"
+      },
       stop = {
        args = "()",
        description = "Stops a Source.",
@@ -143,7 +198,7 @@ local love = {
       },
       tell = {
        args = "(unit: TimeUnit)",
-       description = "Stops a Source.",
+       description = "Gets the currently playing position of the Source.",
        returns = "(position: number)",
        type = "function"
       }
@@ -182,7 +237,7 @@ local love = {
     getDistanceModel = {
      args = "()",
      description = "Returns the distance attenuation model.",
-     returns = "(model: string)",
+     returns = "(model: DistanceModel)",
      type = "function"
     },
     getNumSources = {
@@ -216,7 +271,7 @@ local love = {
      type = "function"
     },
     newSource = {
-     args = "(file: string, type: SourceType)",
+     args = "(filename: string, type: SourceType)",
      description = "Creates a new Source from a file, SoundData, or Decoder. Sources created from SoundData are always static.",
      returns = "(source: Source)",
      type = "function"
@@ -246,7 +301,7 @@ local love = {
      type = "function"
     },
     setDistanceModel = {
-     args = "(model: string)",
+     args = "(model: DistanceModel)",
      description = "Sets the distance attenuation model.",
      returns = "()",
      type = "function"
@@ -312,7 +367,7 @@ local love = {
        type = "value"
       },
       keyreleased = {
-       description = "Key releaed",
+       description = "Key released",
        type = "value"
       },
       mousepressed = {
@@ -364,7 +419,7 @@ local love = {
     wait = {
      args = "()",
      description = "Like love.event.poll(), but blocks until there is an event in the queue.",
-     returns = "(e: Event, a: mixed, b: mixed, c: mixed)",
+     returns = "(e: Event, a: mixed, b: mixed, c: mixed, d: mixed)",
      type = "function"
     }
    },
@@ -412,7 +467,7 @@ local love = {
        type = "function"
       },
       seek = {
-       args = "(pos: number)",
+       args = "(position: number)",
        description = "Seek to a position in a file.",
        returns = "(success: boolean)",
        type = "function"
@@ -575,7 +630,7 @@ local love = {
     },
     remove = {
      args = "(name: string)",
-     description = "Removes a file (or directory).",
+     description = "Removes a file or directory.",
      returns = "(ok: boolean)",
      type = "function"
     },
@@ -618,7 +673,7 @@ local love = {
      type = "value"
     },
     Rasterizer = {
-     description = "A Rasterizer handles font rendering, containing the font data (image or true-type font) and drawable glyphs.",
+     description = "A Rasterizer handles font rendering, containing the font data (image or TrueType font font) and drawable glyphs.",
      type = "value"
     },
     newFontData = {
@@ -665,20 +720,24 @@ local love = {
     },
     BlendMode = {
      childs = {
-      canvas = {
-       description = "Support for Canvas.",
+      additive = {
+       description = "Additive blend mode.",
        type = "value"
       },
-      npot = {
-       description = "Support for textures with non-power-of-two textures. See PO2 Syndrome.",
+      alpha = {
+       description = "Alpha blend mode (\"normal\").",
        type = "value"
       },
-      pixeleffect = {
-       description = "Support for PixelEffect.",
+      multiplicative = {
+       description = "Multiply blend mode.",
+       type = "value"
+      },
+      premultiplied = {
+       description = "Premultiplied blend mode.",
        type = "value"
       },
       subtractive = {
-       description = "Support for the subtractive blend mode.",
+       description = "Subtractive blend mode.",
        type = "value"
       }
      },
@@ -693,6 +752,12 @@ local love = {
        returns = "()",
        type = "function"
       },
+      getFilter = {
+       args = "()",
+       description = "Gets the filter mode of the Canvas.",
+       returns = "(min: FilterMode, mag: FilterMode)",
+       type = "function"
+      },
       getImageData = {
        args = "()",
        description = "Returns the image data stored in the Canvas. Think of it as taking a screenshot of the hidden screen that is the Canvas.",
@@ -711,6 +776,12 @@ local love = {
        returns = "()",
        type = "function"
       },
+      setFilter = {
+       args = "(min: FilterMode, mag: FilterMode)",
+       description = "Sets the filter of the Canvas.",
+       returns = "()",
+       type = "function"
+      },
       setWrap = {
        args = "(horiz: WrapMode, vert: WrapMode)",
        description = "Sets the wrapping properties of a Canvas.\n\n This function sets the way the edges of a Canvas are treated if it is scaled or rotated. If the WrapMode is set to \"clamp\", the edge will not be interpolated. If set to \"repeat\", the edge will be interpolated with the pixels on the opposing side of the framebuffer.",
@@ -799,6 +870,28 @@ local love = {
      description = "Defines the shape of characters than can be drawn onto the screen.",
      type = "lib"
     },
+    GraphicsFeature = {
+     childs = {
+      canvas = {
+       description = "Support for Canvas.",
+       type = "value"
+      },
+      npot = {
+       description = "Support for textures with non-power-of-two textures.",
+       type = "value"
+      },
+      pixeleffect = {
+       description = "Support for PixelEffect.",
+       type = "value"
+      },
+      subtractive = {
+       description = "Support for the subtractive blend mode.",
+       type = "value"
+      }
+     },
+     description = "class constants",
+     type = "class"
+    },
     Image = {
      childs = {
       getFilter = {
@@ -1118,21 +1211,21 @@ local love = {
        type = "function"
       }
      },
-     description = "A quadrilateral with texture coordinate information.\n\nQuads can be used to select part of a texture to draw. In this way, one large Texture Atlas can be loaded, and then split up into sub-images.",
+     description = "A quadrilateral with texture coordinate information.\n\nQuads can be used to select part of a texture to draw. In this way, one large texture atlas can be loaded, and then split up into sub-images.",
      type = "lib"
     },
     SpriteBatch = {
      childs = {
       add = {
-       args = "(x: number, y: number, r: number, sx: number, sy: number, ox: number, oy: number)",
+       args = "(x: number, y: number, r: number, sx: number, sy: number, ox: number, oy: number, kx: number, ky: number)",
        description = "Add a sprite to the batch.",
-       returns = "()",
+       returns = "(id: number)",
        type = "function"
       },
       addq = {
        args = "()",
        description = "Add a Quad to the batch.",
-       returns = "(quad: Quad, x: number, y: number, r: number, sx: number, sy: number, ox: number, oy: number)",
+       returns = "(id: number)",
        type = "function"
       },
       bind = {
@@ -1147,12 +1240,36 @@ local love = {
        returns = "()",
        type = "function"
       },
+      getImage = {
+       args = "()",
+       description = "Returns the image used by the SpriteBatch.",
+       returns = "(image: Image)",
+       type = "function"
+      },
+      set = {
+       args = "()",
+       description = "Changes a sprite in the batch. This requires the identifier returned by add and addq.",
+       returns = "(id: number, x: number, y: number, r: number, sx: number, sy: number, ox: number, oy: number, kx: number, ky: number)",
+       type = "function"
+      },
+      setColor = {
+       args = "(r: number, g: number, b: number, a: number)",
+       description = "Sets the color that will be used for the next add and set operations. Calling the function without arguments will clear the color.\n\nThe global color set with love.graphics.setColor will not work on the SpriteBatch if any of the sprites has its own color.",
+       returns = "()",
+       type = "function"
+      },
       setImage = {
        args = "(image: Image)",
        description = "Replaces the image used for the sprites.",
        returns = "()",
        type = "function"
       },
+      setq = {
+       args = "()",
+       description = "Changes a sprite with a quad in the batch. This requires the identifier returned by add and addq.",
+       returns = "(id: number)",
+       type = "function"
+      },
       unbind = {
        args = "()",
        description = "Unbinds the SpriteBatch.",
@@ -1267,12 +1384,6 @@ local love = {
      returns = "(height: number)",
      type = "function"
     },
-    getLineStipple = {
-     args = "()",
-     description = "Gets the current line stipple.",
-     returns = "(pattern: number, repeat: number)",
-     type = "function"
-    },
     getLineStyle = {
      args = "()",
      description = "Gets the line style.",
@@ -1357,12 +1468,6 @@ local love = {
      returns = "()",
      type = "function"
     },
-    ["love.graphics.newStencil"] = {
-     args = "(stencilFunction: function)",
-     description = "Creates a new stencil.",
-     returns = "(myStencil: function)",
-     type = "function"
-    },
     newCanvas = {
      args = "()",
      description = "Creates a new Canvas object for offscreen rendering.",
@@ -1383,7 +1488,7 @@ local love = {
     },
     newImageFont = {
      args = "(image: Image, glyphs: string)",
-     description = "Creates a new font by loading a specifically formatted image. There can be up to 256 glyphs.",
+     description = "Creates a new font by loading a specifically formatted image. There can be up to 256 glyphs.\n\nExpects ISO 8859-1 encoding for the glyphs string.",
      returns = "(font: Font)",
      type = "function"
     },
@@ -1395,7 +1500,7 @@ local love = {
     },
     newPixelEffect = {
      args = "(code: string)",
-     description = "Creates a new PixelEffect object for hardware-accelerated pixel level effects.\n\nA PixelEffect contains at least one function, named effect, which is the effect itself, but it can contain additional functions.\n\nvec4 effect( vec4 color, sampler2D texture, vec2 texture_coords, vec2 pixel_coords )",
+     description = "Creates a new PixelEffect object for hardware-accelerated pixel level effects.\n\nA PixelEffect contains at least one function, named effect, which is the effect itself, but it can contain additional functions.\n\nvec4 effect( vec4 color, Image texture, vec2 texture_coords, vec2 pixel_coords )",
      returns = "(pixeleffect: PixelEffect)",
      type = "function"
     },
@@ -1417,6 +1522,12 @@ local love = {
      returns = "(spriteBatch: SpriteBatch)",
      type = "function"
     },
+    newStencil = {
+     args = "(stencilFunction: function)",
+     description = "Creates a new stencil.",
+     returns = "(myStencil: function)",
+     type = "function"
+    },
     point = {
      args = "(x: number, y: number)",
      description = "Draws a point.\n\nThe pixel grid is actually offset to the center of each pixel. So to get clean pixels drawn use 0.5 + integer increments.",
@@ -1443,7 +1554,7 @@ local love = {
     },
     print = {
      args = "(text: string, x: number, y: number, r: number, sx: number, sy: number, ox: number, oy: number, kx: number, ky: number)",
-     description = "Draws text on screen. If no Font is set, one will be created and set (once) if needed.\n\nAs of LÖVE 0.7.1, when using translation and scaling functions while drawing text, this function assumes the scale occurs first. If you don't script with this in mind, the text won't be in the right position, or possibly even on screen.\n\nDrawing uses the current color, but only if the ColorMode is \"modulate\" (which is the default). If your text is displayed as white, it is probably because the color mode is \"replace\" (which is useful when drawing sprites). Change the color model to \"modulate\" before drawing.\n\nlove.graphics.print stops at the first '\000' (null) character. This can bite you if you are appending keystrokes to form your string, as some of those are multi-byte unicode characters which will likely contain null bytes.",
+     description = "Draws text on screen. If no Font is set, one will be created and set (once) if needed.\n\nWhen using translation and scaling functions while drawing text, this function assumes the scale occurs first. If you don't script with this in mind, the text won't be in the right position, or possibly even on screen.\n\nDrawing uses the current color, but only if the ColorMode is \"modulate\" (which is the default). If your text is displayed as white, it is probably because the color mode is \"replace\" (which is useful when drawing sprites). Change the color model to \"modulate\" before drawing.\n\nlove.graphics.print stops at the first '\000' (null) character. This can bite you if you are appending keystrokes to form your string, as some of those are multi-byte unicode characters which will likely contain null bytes.",
      returns = "()",
      type = "function"
     },
@@ -1473,24 +1584,24 @@ local love = {
     },
     reset = {
      args = "()",
-     description = "Resets the current graphics settings.\n\nCalling reset makes the current drawing color white, the current background color black, the window title empty and removes any scissor settings. It sets the BlendMode to alpha and ColorMode to modulate. It also sets both the point and line drawing modes to smooth and their sizes to 1.0 . Finally, it removes any stipple settings.",
+     description = "Resets the current graphics settings.\n\nCalling reset makes the current drawing color white, the current background color black, the window title empty and removes any scissor settings. It sets the BlendMode to alpha and ColorMode to modulate. It also sets both the point and line drawing modes to smooth and their sizes to 1.0.",
      returns = "()",
      type = "function"
     },
     rotate = {
      args = "(angle: number)",
-     description = "Rotates the coordinate system in two dimensions.\n\nCalling this function affects all future drawing operations by rotating the coordinate system around the origin by the given amount of radians. This change lasts until love.draw() exits.",
+     description = "Rotates the coordinate system in two dimensions.\n\nCalling this function affects all future drawing operations by rotating the coordinate system around the origin by the given amount of radians. This change lasts until love.draw exits.",
      returns = "()",
      type = "function"
     },
     scale = {
      args = "(sx: number, sy: number)",
-     description = "Scales the coordinate system in two dimensions.\n\nBy default the coordinate system in LÖVE corresponds to the display pixels in horizontal and vertical directions one-to-one, and the x-axis increases towards the right while the y-axis increases downwards. Scaling the coordinate system changes this relation.\n\nAfter scaling by sx and sy, all coordinates are treated as if they were multiplied by sx and sy. Every result of a drawing operation is also correspondingly scaled, so scaling by (2, 2) for example would mean making everything twice as large in both x- and y-directions. Scaling by a negative value flips the coordinate system in the corresponding direction, which also means everything will be drawn flipped or upside down, or both. Scaling by zero is not a useful operation.\n\nScale and translate are not commutative operations, therefore, calling them in different orders will change the outcome.\n\nScaling lasts until love.draw() exits.",
+     description = "Scales the coordinate system in two dimensions.\n\nBy default the coordinate system in LÖVE corresponds to the display pixels in horizontal and vertical directions one-to-one, and the x-axis increases towards the right while the y-axis increases downwards. Scaling the coordinate system changes this relation.\n\nAfter scaling by sx and sy, all coordinates are treated as if they were multiplied by sx and sy. Every result of a drawing operation is also correspondingly scaled, so scaling by (2, 2) for example would mean making everything twice as large in both x- and y-directions. Scaling by a negative value flips the coordinate system in the corresponding direction, which also means everything will be drawn flipped or upside down, or both. Scaling by zero is not a useful operation.\n\nScale and translate are not commutative operations, therefore, calling them in different orders will change the outcome.\n\nScaling lasts until love.draw exits.",
      returns = "()",
      type = "function"
     },
     setBackgroundColor = {
-     args = "(r: number, g: number, b: number)",
+     args = "(r: number, g: number, b: number, a: number)",
      description = "Sets the background color.",
      returns = "()",
      type = "function"
@@ -1545,7 +1656,7 @@ local love = {
     },
     setInvertedStencil = {
      args = "(stencilFunction: function)",
-     description = "Defines an inverted stencil for the drawing operations or releases the active one.\n\nIt's the same as love.graphics.setStencil with the mask inverted.",
+     description = "Defines an inverted stencil for the drawing operations or releases the active one.\n\nIt's the same as love.graphics.setStencil with the mask inverted.\n\nCalling the function without arguments releases the active stencil.",
      returns = "()",
      type = "function"
     },
@@ -1555,12 +1666,6 @@ local love = {
      returns = "()",
      type = "function"
     },
-    setLineStipple = {
-     args = "(pattern: number, repeat: number)",
-     description = "Sets the line stipple pattern.\n\nA stipple pattern is made up of a 16bit sequence of 0s and 1s, Just like binary.\n\nThe pattern is repeated to complete the line. Using the repeat will stretch the pattern and multiplies each 1 and 0. For example if three 1s are consecutively placed they are stretched to six if the repeat is 2. The maximum repeat is 255, and the minimum repeat is 1.\n\nA 1 is a a cue to draw a pixel whereas 0 is the opposite and does not draw a pixel, This is done per pixel for the given line.\n\nA pattern is read from back to front.\n\n0x3F07 would equal to 0011111100000111 in binary.\n\nYou can visualise the pattern by reading the binary sequence backwards.",
-     returns = "()",
-     type = "function"
-    },
     setLineStyle = {
      args = "(style: LineStyle)",
      description = "Sets the line style.",
@@ -1580,7 +1685,7 @@ local love = {
      type = "function"
     },
     setNewFont = {
-     args = "(filename: string, size: number)",
+     args = "(size: number)",
      description = "Creates and sets a new font.",
      returns = "(font: Font)",
      type = "function"
@@ -1617,7 +1722,7 @@ local love = {
     },
     setStencil = {
      args = "(stencilFunction: function)",
-     description = "Defines or releases a stencil for the drawing operations.\n\nThe passed function draws to the stencil instead of the screen, creating an image with transparent and opaque pixel. While active, it is used to test where pixel will be drawn or discarded.\n\nCalling the function without arguments releases the active stencil.",
+     description = "Defines or releases a stencil for the drawing operations.\n\nThe passed function draws to the stencil instead of the screen, creating an image with transparent and opaque pixels. While active, it is used to test where pixels will be drawn or discarded.\n\nCalling the function without arguments releases the active stencil.",
      returns = "()",
      type = "function"
     },
@@ -1635,7 +1740,7 @@ local love = {
     },
     translate = {
      args = "(dx: number, dy: number)",
-     description = "Translates the coordinate system in two dimensions.\n\nWhen this function is called with two numbers, dx, and dy, all the following drawing operations take effect as if their x and y coordinates were x+dx and y+dy.\n\nScale and translate are not commutative operations, therefore, calling them in different orders will change the outcome.\n\nThis change lasts until love.draw() exits or else a love.graphics.pop reverts to a previous love.graphics.push.\n\nTranslating using whole numbers will prevent tearing/blurring of images and fonts draw after translating.",
+     description = "Translates the coordinate system in two dimensions.\n\nWhen this function is called with two numbers, dx, and dy, all the following drawing operations take effect as if their x and y coordinates were x+dx and y+dy.\n\nScale and translate are not commutative operations, therefore, calling them in different orders will change the outcome.\n\nThis change lasts until love.draw exits or else a love.graphics.pop reverts to a previous love.graphics.push.\n\nTranslating using whole numbers will prevent tearing/blurring of images and fonts draw after translating.",
      returns = "()",
      type = "function"
     },
@@ -1646,12 +1751,66 @@ local love = {
      type = "function"
     }
    },
-   description = "The primary responsibility for the love.graphics module is the drawing of lines, shapes, text, Images and other Drawable objects onto the screen. Its secondary responsibilities include loading external files (including Images and Fonts) into memory, creating specialized objects (such as ParticleSystems or Framebuffers) and managing screen geometry.\n\nLÖVE's coordinate system is rooted in the upper-left corner of the screen, which is at location (0, 0). The x axis is horizontal: larger values are further to the right. The y axis is vertical: larger values are further towards the bottom.\n\nIn many cases, you draw images or shapes in terms of their upper-left corner (See the picture above).\n\nMany of the functions are used to manipulate the graphics coordinate system, which is essentially the the way coordinates are mapped to the display. You can change the position, scale, and even rotation in this way.",
+   description = "The primary responsibility for the love.graphics module is the drawing of lines, shapes, text, Images and other Drawable objects onto the screen. Its secondary responsibilities include loading external files (including Images and Fonts) into memory, creating specialized objects (such as ParticleSystems or Framebuffers) and managing screen geometry.\n\nLÖVE's coordinate system is rooted in the upper-left corner of the screen, which is at location (0, 0). The x-axis is horizontal: larger values are further to the right. The y-axis is vertical: larger values are further towards the bottom.\n\nIn many cases, you draw images or shapes in terms of their upper-left corner (See the picture above).\n\nMany of the functions are used to manipulate the graphics coordinate system, which is essentially the the way coordinates are mapped to the display. You can change the position, scale, and even rotation in this way.",
    type = "class"
   },
   image = {
    childs = {
     ImageData = {
+     childs = {
+      encode = {
+       args = "(outFile: string)",
+       description = "Encodes the ImageData and writes it to the save directory.",
+       returns = "()",
+       type = "function"
+      },
+      getHeight = {
+       args = "()",
+       description = "Gets the height of the ImageData.",
+       returns = "(height: number)",
+       type = "function"
+      },
+      getPixel = {
+       args = "(x: number, y: number)",
+       description = "Gets the pixel at the specified position.\n\nValid x and y values start at 0 and go up to image width and height minus 1.",
+       returns = "(r: number, g: number, b: number, a: number)",
+       type = "function"
+      },
+      getString = {
+       args = "()",
+       description = "Gets the full ImageData as a string.",
+       returns = "(pixels: string)",
+       type = "function"
+      },
+      getWidth = {
+       args = "()",
+       description = "Gets the width of the ImageData.",
+       returns = "(width: number)",
+       type = "function"
+      },
+      mapPixel = {
+       args = "(pixelFunction: function)",
+       description = "Transform an image by applying a function to every pixel.\n\nThis function is a higher order function. It takes another function as a parameter, and calls it once for each pixel in the ImageData.\n\nThe function parameter is called with six parameters for each pixel in turn. The parameters are numbers that represent the x and y coordinates of the pixel and its red, green, blue and alpha values. The function parameter can return up to four number values, which become the new r, g, b and a values of the pixel. If the function returns fewer values, the remaining components are set to 0.",
+       returns = "()",
+       type = "function"
+      },
+      paste = {
+       args = "(source: ImageData, dx: number, dy: number, sx: number, sy: number, sw: number, sh: number)",
+       description = "Paste into ImageData from another source ImageData.",
+       returns = "()",
+       type = "function"
+      },
+      setPixel = {
+       args = "(x: number, y: number, r: number, g: number, b: number, a: number)",
+       description = "Sets the color of a pixel.\n\nValid x and y values start at 0 and go up to image width and height minus 1.",
+       returns = "()",
+       type = "function"
+      }
+     },
+     description = "Raw (decoded) image data.\n\nYou can't draw ImageData directly to screen. See Image for that.",
+     type = "lib"
+    },
+    ImageFormat = {
      childs = {
       bmp = {
        description = "BMP image format.",
@@ -1677,12 +1836,6 @@ local love = {
      description = "class constants",
      type = "class"
     },
-    newEncodedImageData = {
-     args = "(imageData: ImageData, format: ImageFormat)",
-     description = "Encodes ImageData.",
-     returns = "(data: Data)",
-     type = "function"
-    },
     newImageData = {
      args = "(width: number, height: number)",
      description = "Create a new ImageData object.",
@@ -1757,7 +1910,7 @@ local love = {
     },
     getBall = {
      args = "(joystick: number, ball: number)",
-     description = "Returns the change in Ball position.",
+     description = "Returns the change in ball position.",
      returns = "(dx: number, dy: number)",
      type = "function"
     },
@@ -2053,7 +2206,7 @@ local love = {
        type = "value"
       },
       euro = {
-       description = "Euro (€) key",
+       description = "Euro (€) key",
        type = "value"
       },
       f = {
@@ -2473,19 +2626,19 @@ local love = {
     },
     getX = {
      args = "()",
-     description = "Returns the current x-position of the mouse.",
+     description = "Returns the current x position of the mouse.",
      returns = "(x: number)",
      type = "function"
     },
     getY = {
      args = "()",
-     description = "Returns the current y-position of the mouse.",
+     description = "Returns the current y position of the mouse.",
      returns = "(y: number)",
      type = "function"
     },
     isDown = {
      args = "(button: MouseConstant)",
-     description = "Checks whether a certain mouse button is down.",
+     description = "Checks whether a certain mouse button is down. This function does not detect mousewheel scrolling; you must use the love.mousepressed callback for that.",
      returns = "(down: boolean)",
      type = "function"
     },
@@ -2577,7 +2730,7 @@ local love = {
       },
       getAngle = {
        args = "()",
-       description = "Get the angle of the body.\n\nThe angle is measured in radians. If you need to transform it to degrees, use math.deg.\n\nA value of 0 radians will mean \"looking to the right\". Although radians increase counter-clockwise, the y axis points down so it becomes clockwise from our point of view.",
+       description = "Get the angle of the body.\n\nThe angle is measured in radians. If you need to transform it to degrees, use math.deg.\n\nA value of 0 radians will mean \"looking to the right\". Although radians increase counter-clockwise, the y-axis points down so it becomes clockwise from our point of view.",
        returns = "(angle: number)",
        type = "function"
       },
@@ -2599,6 +2752,12 @@ local love = {
        returns = "(fixtures: table)",
        type = "function"
       },
+      getGravityScale = {
+       args = "()",
+       description = "Returns the gravity scale factor.",
+       returns = "(scale: number)",
+       type = "function"
+      },
       getInertia = {
        args = "()",
        description = "Gets the rotational inertia of the body.\n\nThe rotational inertia is how hard is it to make the body spin. It is set with the 4th argument to Body:setMass, or automatically with Body:setMassFromShapes.",
@@ -2773,6 +2932,12 @@ local love = {
        returns = "()",
        type = "function"
       },
+      setActive = {
+       args = "(active: boolean)",
+       description = "Sets whether the body is active in the world.\n\nAn inactive body does not take part in the simulation. It will not move or cause any collisions.",
+       returns = "()",
+       type = "function"
+      },
       setAllowSleeping = {
        args = "(permission: boolean)",
        description = "Set the sleep behaviour of a body.\n\nA sleeping body is much more efficient to simulate than when awake.\n\nIf sleeping is allowed, a body that has come to rest will sleep.",
@@ -2781,7 +2946,7 @@ local love = {
       },
       setAngle = {
        args = "(angle: number)",
-       description = "Set the angle of the body.\n\nThe angle is measured in radians. If you need to transform it from degrees, use math.rad.\n\nA value of 0 radians will mean \"looking to the right\". .Although radians increase counter-clockwise, the y axis points down so it becomes clockwise from our point of view.\n\nIt is possible to cause a collision with another body by changing its angle.",
+       description = "Set the angle of the body.\n\nThe angle is measured in radians. If you need to transform it from degrees, use math.rad.\n\nA value of 0 radians will mean \"looking to the right\". .Although radians increase counter-clockwise, the y-axis points down so it becomes clockwise from our point of view.\n\nIt is possible to cause a collision with another body by changing its angle.",
        returns = "()",
        type = "function"
       },
@@ -2915,6 +3080,48 @@ local love = {
      description = "class constants",
      type = "class"
     },
+    ChainShape = {
+     childs = {
+      getChildEdge = {
+       args = "(index: number)",
+       description = "Returns a child of the shape as an EdgeShape.",
+       returns = "(EdgeShape: number)",
+       type = "function"
+      },
+      getPoint = {
+       args = "(index: number)",
+       description = "Returns a point of the shape.",
+       returns = "(x: number, y: number)",
+       type = "function"
+      },
+      getPoints = {
+       args = "()",
+       description = "Returns all points of the shape.",
+       returns = "(x1: number, y1: number, x2: number, y2: number, ...: number)",
+       type = "function"
+      },
+      getVertexCount = {
+       args = "()",
+       description = "Returns the number of vertices the shape has.",
+       returns = "(count: number)",
+       type = "function"
+      },
+      setNextVertex = {
+       args = "(x: number, y: number)",
+       description = "Sets a vertex that establishes a connection to the next shape.\n\nThis can help prevent unwanted collisions when a flat shape slides along the edge and moves over to the new shape.",
+       returns = "()",
+       type = "function"
+      },
+      setPrevVertex = {
+       args = "(x: number, y: number)",
+       description = "Sets a vertex that establishes a connection to the previous shape.\n\nThis can help prevent unwanted collisions when a flat shape slides along the edge and moves over to the new shape.",
+       returns = "()",
+       type = "function"
+      }
+     },
+     description = "A ChainShape consists of multiple line segments. It can be used to create the boundaries of your terrain. The shape does not have volume and can only collide with PolygonShape and CircleShape.\n\nUnlike the PolygonShape, the ChainShape does not have a vertices limit or has to form a convex shape, but self intersections are not supported. ",
+     type = "lib"
+    },
     CircleShape = {
      childs = {
       getLocalCenter = {
@@ -2934,6 +3141,12 @@ local love = {
        description = "Get the center of the circle in world coordinates.",
        returns = "(wx: number, wy: number)",
        type = "function"
+      },
+      setRadius = {
+       args = "(radius: number)",
+       description = "Sets the radius of the circle.",
+       returns = "()",
+       type = "function"
       }
      },
      description = "Circle extends Shape and adds a radius and a local position.",
@@ -2953,10 +3166,10 @@ local love = {
        returns = "(nx: number, ny: number)",
        type = "function"
       },
-      getPosition = {
+      getPositions = {
        args = "()",
-       description = "Get the location of the contact point between two shapes.",
-       returns = "(cx: number, cy: number)",
+       description = "Returns the contact points of the two colliding fixtures. There can be one or two points.",
+       returns = "(x1: number, y1: number, x2: number, y2: number)",
        type = "function"
       },
       getRestitution = {
@@ -2971,10 +3184,46 @@ local love = {
        returns = "(distance: number)",
        type = "function"
       },
-      getVelocity = {
+      isEnabled = {
        args = "()",
-       description = "Get the linear impact velocity of a contact.",
-       returns = "(vx: number, vy: number)",
+       description = "Returns whether the contact is enabled. The collision will be ignored if a contact gets disabled in the post solve callback.",
+       returns = "(enabled: boolean)",
+       type = "function"
+      },
+      isTouching = {
+       args = "()",
+       description = "Returns whether the two colliding fixtures are touching each other.",
+       returns = "(touching: boolean)",
+       type = "function"
+      },
+      resetFriction = {
+       args = "()",
+       description = "Resets the contact friction to the mixture value of both fixtures.",
+       returns = "()",
+       type = "function"
+      },
+      resetRestitution = {
+       args = "()",
+       description = "Resets the contact restitution to the mixture value of both fixtures.",
+       returns = "()",
+       type = "function"
+      },
+      setEnabled = {
+       args = "(enabled: boolean)",
+       description = "Enables or disables the contact.",
+       returns = "()",
+       type = "function"
+      },
+      setFriction = {
+       args = "(friction: number)",
+       description = "Sets the contact friction.",
+       returns = "()",
+       type = "function"
+      },
+      setRestitution = {
+       args = "(restitution: number)",
+       description = "Sets the contact restitution.",
+       returns = "()",
        type = "function"
       }
      },
@@ -3023,6 +3272,12 @@ local love = {
      description = "Keeps two bodies at the same distance.",
      type = "lib"
     },
+    EdgeShape = {
+     args = "()",
+     description = "A EdgeShape is a line segment. They can be used to create the boundaries of your terrain. The shape does not have volume and can only collide with PolygonShape and CircleShape.",
+     returns = "()",
+     type = "function"
+    },
     Fixture = {
      childs = {
       destroy = {
@@ -3254,8 +3509,8 @@ local love = {
        type = "function"
       },
       getReactionTorque = {
-       args = "()",
-       description = "Gets the reaction torque on Body 2.",
+       args = "(invdt: number)",
+       description = "Returns the reaction torque on the second body.",
        returns = "(torque: number)",
        type = "function"
       },
@@ -3307,6 +3562,18 @@ local love = {
     },
     MouseJoint = {
      childs = {
+      getDampingRatio = {
+       args = "()",
+       description = "Returns the damping ratio.",
+       returns = "(ratio: number)",
+       type = "function"
+      },
+      getFrequency = {
+       args = "()",
+       description = "Returns the frequency.",
+       returns = "(freq: number)",
+       type = "function"
+      },
       getMaxForce = {
        args = "()",
        description = "Gets the highest allowed force.",
@@ -3319,6 +3586,18 @@ local love = {
        returns = "(x: number, y: number)",
        type = "function"
       },
+      setDampingRatio = {
+       args = "(ratio: number)",
+       description = "Sets a new damping ratio.",
+       returns = "()",
+       type = "function"
+      },
+      setFrequency = {
+       args = "(freq: number)",
+       description = "Sets a new frequency.",
+       returns = "()",
+       type = "function"
+      },
       setMaxForce = {
        args = "(f: number)",
        description = "Sets the highest allowed force.",
@@ -3343,6 +3622,18 @@ local love = {
     },
     PrismaticJoint = {
      childs = {
+      enableLimit = {
+       args = "(enable: boolean)",
+       description = "Enables or disables the limits of the joint.",
+       returns = "()",
+       type = "function"
+      },
+      enableMotor = {
+       args = "(enable: boolean)",
+       description = "Starts or stops the joint motor.",
+       returns = "()",
+       type = "function"
+      },
       getJointSpeed = {
        args = "()",
        description = "Get the current joint angle speed.",
@@ -3391,9 +3682,9 @@ local love = {
        returns = "(upper: number)",
        type = "function"
       },
-      isLimitsEnabled = {
+      isLimitEnabled = {
        args = "()",
-       description = "Checks whether limits are enabled.",
+       description = "Checks whether the limits are enabled.",
        returns = "(enabled: boolean)",
        type = "function"
       },
@@ -3409,12 +3700,6 @@ local love = {
        returns = "()",
        type = "function"
       },
-      setLimitsEnabled = {
-       args = "(enable: boolean)",
-       description = "Enables/disables the joint limit.",
-       returns = "()",
-       type = "function"
-      },
       setLowerLimit = {
        args = "(lower: number)",
        description = "Sets the lower limit.",
@@ -3427,12 +3712,6 @@ local love = {
        returns = "()",
        type = "function"
       },
-      setMotorEnabled = {
-       args = "(enable: boolean)",
-       description = "Enables/disables the joint motor.",
-       returns = "()",
-       type = "function"
-      },
       setMotorSpeed = {
        args = "(s: number)",
        description = "Sets the motor speed.",
@@ -3463,13 +3742,13 @@ local love = {
        returns = "(a1x: number, a1y: number, a2x: number, a2y: number)",
        type = "function"
       },
-      getLength1 = {
+      getLengthA = {
        args = "()",
        description = "Get the current length of the rope segment attached to the first body.",
        returns = "(length: number)",
        type = "function"
       },
-      getLength2 = {
+      getLengthB = {
        args = "()",
        description = "Get the current length of the rope segment attached to the second body.",
        returns = "(length: number)",
@@ -3511,9 +3790,15 @@ local love = {
     },
     RevoluteJoint = {
      childs = {
+      enableLimits = {
+       args = "(enable: boolean)",
+       description = "Enables or disables the joint limits.",
+       returns = "()",
+       type = "function"
+      },
       enableMotor = {
        args = "(enable: boolean)",
-       description = "Enables/disables the joint motor.",
+       description = "Starts or stops the joint motor.",
        returns = "()",
        type = "function"
       },
@@ -3766,8 +4051,34 @@ local love = {
      type = "class"
     },
     WeldJoint = {
+     childs = {
+      getDampingRatio = {
+       args = "()",
+       description = "Returns the damping ratio of the joint.",
+       returns = "(ratio: number)",
+       type = "function"
+      },
+      getFrequency = {
+       args = "()",
+       description = "Returns the frequency.",
+       returns = "(freq: number)",
+       type = "function"
+      },
+      setDampingRatio = {
+       args = "(ratio: number)",
+       description = "The new damping ratio.",
+       returns = "()",
+       type = "function"
+      },
+      setFrequency = {
+       args = "()",
+       description = "Sets a new frequency.",
+       returns = "(freq: number)",
+       type = "function"
+      }
+     },
      description = "A WeldJoint essentially glues two bodies together.",
-     type = "value"
+     type = "lib"
     },
     World = {
      childs = {
@@ -3797,8 +4108,8 @@ local love = {
       },
       getCallbacks = {
        args = "()",
-       description = "Get functions to be called when two shapes collide.",
-       returns = "(add: function, persist: function, remove: function, result: function)",
+       description = "Returns functions for the callbacks during the world update.",
+       returns = "(beginContact: function, endContact: function, preSolve: function, postSolve: function)",
        type = "function"
       },
       getContactCount = {
@@ -3926,7 +4237,7 @@ local love = {
      type = "function"
     },
     newEdgeShape = {
-     args = "(body1: Body, body2: Body, x: number, y: number)",
+     args = "(x1: number, y1: number, x2: number, y2: number)",
      description = "Creates a edge shape.",
      returns = "(shape: EdgeShape)",
      type = "function"
@@ -4008,6 +4319,12 @@ local love = {
      description = "Creates a new World.",
      returns = "(world: World)",
      type = "function"
+    },
+    setMeter = {
+     args = "(scale: number)",
+     description = "Sets the meter scale factor.\n\nAll coordinates in the physics module are divided by this number, creating a convenient way to draw the objects directly to the screen without the need for graphics transformations.\n\nIt is recommended to create shapes no larger than 10 times the scale. This is important because Box2D is tuned to work well with shape sizes from 0.1 to 10 meters.",
+     returns = "()",
+     type = "function"
     }
    },
    description = "Can simulate 2D rigid body physics in a realistic manner. This module is based on Box2D, and this API corresponds to the Box2D API as closely as possible.",
@@ -4119,6 +4436,12 @@ local love = {
        returns = "(value: mixed)",
        type = "function"
       },
+      getKeys = {
+       args = "()",
+       description = "Returns the names of all messages in a table.",
+       returns = "(msgNames: table)",
+       type = "function"
+      },
       getName = {
        args = "()",
        description = "Get the name of a thread.",
@@ -4167,7 +4490,7 @@ local love = {
     },
     newThread = {
      args = "(name: string, filename: string)",
-     description = "Creates a new Thread from a File or Data Object.",
+     description = "Creates a new Thread from a File or Data object.",
      returns = "(thread: Thread)",
      type = "function"
     }

bin/lua

@@ -0,0 +1 @@
+lua.app/Contents/MacOS/lua

bin/lua.app/Contents/Info.plist

@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>English</string>
+	<key>CFBundleExecutable</key>
+        <string>lua</string>
+        <key>CFBundleDisplayName</key>
+        <string>Lua</string>
+	<key>CFBundleGetInfoString</key>
+	<string></string>
+	<key>CFBundleIconFile</key>
+	<string></string>
+	<key>CFBundleIdentifier</key>
+	<string>org.Lua.LuaInterpreter</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleLongVersionString</key>
+	<string></string>
+	<key>CFBundleName</key>
+	<string>Lua</string>
+	<key>CFBundlePackageType</key>
+	<string>APPL</string>
+	<key>CFBundleShortVersionString</key>
+	<string></string>
+	<key>CFBundleSignature</key>
+	<string>????</string>
+	<key>CFBundleVersion</key>
+	<string></string>
+	<key>CSResourcesFileMapped</key>
+	<true/>
+	<key>LSRequiresCarbon</key>
+	<true/>
+	<key>NSHumanReadableCopyright</key>
+	<string></string>
+</dict>
+</plist>

bin/lua52

@@ -0,0 +1 @@
+lua.app/Contents/MacOS/lua52

build/CMakeLists.txt

@@ -0,0 +1,144 @@
+# setup the minimum allowed CMake version
+cmake_minimum_required(VERSION 2.8)
+
+# set the default build type (this needs to be done *before* project command)
+if(NOT CMAKE_BUILD_TYPE)
+  set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build." FORCE)
+  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "RelWithDebInfo" "MinSizeRel")
+endif()
+
+# restrict configuration types to the selected build type
+set(CMAKE_CONFIGURATION_TYPES ${CMAKE_BUILD_TYPE} CACHE INTERNAL "" FORCE)
+
+# set the project name
+project("zbstudio")
+
+# set the top-level project directory relative to CMakeLists.txt location
+set(TOPDIR ..)
+
+# checks if the Lua module is available
+function(check_lua_module MODULE)
+  if(NOT ${MODULE}_FOUND)
+    # find Lua executable at first
+    find_program(LUA_EXECUTABLE "lua")
+    if(NOT LUA_EXECUTABLE)
+      message(FATAL_ERROR "Lua executable is not found")
+    endif()
+
+    # run a short script with "require" statement to determine if the Lua module is available
+    execute_process(COMMAND "${LUA_EXECUTABLE}" -e "require(\"${MODULE}\")"
+      RESULT_VARIABLE EXIT_CODE OUTPUT_QUIET ERROR_QUIET)
+    if(EXIT_CODE EQUAL 0)
+      set(${MODULE}_FOUND TRUE CACHE INTERNAL "")
+      message(STATUS "Found Lua module: ${MODULE}")
+    elseif(ARGV1)
+      message(FATAL_ERROR "Lua module \"${MODULE}\" is not found")
+    endif()
+  endif()
+endfunction()
+
+# adds an user option to select between system-wide and bundled Lua module
+function(add_system_lua_module_option MODULE)
+  string(TOUPPER ${MODULE} UPPERCASE_MODULE)
+  if(NOT DEFINED USE_SYSTEM_${UPPERCASE_MODULE})
+    option(USE_SYSTEM_${UPPERCASE_MODULE}
+      "Use a system-wide \"${MODULE}\" Lua module instead of the bundled one." ${${MODULE}_FOUND})
+  endif()
+endfunction()
+
+# installs all files listed in the manifest
+function(install_from_manifest TYPE MANIFEST DESTDIR EXCLUDE_REGEX)
+  file(STRINGS ${MANIFEST} PATTERN_LIST)
+  foreach(PATTERN ${PATTERN_LIST})
+    string(STRIP ${PATTERN} PATTERN)
+    if(NOT PATTERN MATCHES ${EXCLUDE_REGEX})
+      file(GLOB FILELIST RELATIVE "${CMAKE_SOURCE_DIR}/${TOPDIR}" "${CMAKE_SOURCE_DIR}/${TOPDIR}/${PATTERN}")
+      foreach(FILENAME ${FILELIST})
+        get_filename_component(FILEPATH ${FILENAME} PATH)
+        install(${TYPE} ${TOPDIR}/${FILENAME} DESTINATION ${DESTDIR}/${FILEPATH})
+      endforeach()
+    endif()
+  endforeach()
+endfunction()
+
+if(WIN32)
+  # add the executable file to our project
+  add_executable(zbstudio WIN32 ${TOPDIR}/build/win32_starter.c ${TOPDIR}/zbstudio/res/zbstudio.rc)
+
+  # link to the static multi-threaded CRT under MSVC
+  if(MSVC)
+    string(TOUPPER ${CMAKE_BUILD_TYPE} BUILD_TYPE)
+    foreach(FLAGS_VAR CMAKE_C_FLAGS CMAKE_CXX_FLAGS CMAKE_C_FLAGS_${BUILD_TYPE} CMAKE_CXX_FLAGS_${BUILD_TYPE})
+      string(REGEX REPLACE "/MD" "/MT" ${FLAGS_VAR} ${${FLAGS_VAR}})
+      string(REGEX REPLACE "/MDd" "/MTd" ${FLAGS_VAR} ${${FLAGS_VAR}})
+    endforeach()
+  endif()
+
+  # setup the data directory
+  set(DATADIR .)
+
+  # install IDE executable
+  install(TARGETS zbstudio DESTINATION ${DATADIR})
+
+  # install files from manifest
+  install_from_manifest(FILES ${TOPDIR}/zbstudio/MANIFEST ${DATADIR} "^$")
+  install_from_manifest(FILES ${TOPDIR}/zbstudio/MANIFEST-bin-win32 ${DATADIR} "^zbstudio.exe$")
+elseif(APPLE)
+  set(OSX_INSTALL_PREFIX "/Applications" CACHE PATH "Default OSX prefix")
+  set(CMAKE_INSTALL_PREFIX "${OSX_INSTALL_PREFIX}" CACHE INTERNAL "Prefix prepended to install directories")
+  # setup the data directory
+  set(ROOTDIR ZeroBraneStudio.app/Contents)
+  set(DATADIR ${ROOTDIR}/ZeroBraneStudio)
+
+  # install IDE shell script
+  install(PROGRAMS ${TOPDIR}/zbstudio/ZeroBraneStudio.app/Contents/MacOS/ZeroBraneStudio DESTINATION ${ROOTDIR}/MacOS)
+
+  # install icon pack and .plist file
+  install(DIRECTORY ${TOPDIR}/zbstudio/ZeroBraneStudio.app/Contents/Resources DESTINATION ${ROOTDIR})
+  install(FILES ${TOPDIR}/zbstudio/ZeroBraneStudio.app/Contents/Info.plist DESTINATION ${ROOTDIR})
+
+  # install files from manifest
+  install_from_manifest(FILES ${TOPDIR}/zbstudio/MANIFEST ${DATADIR} "^$")
+  install_from_manifest(PROGRAMS ${TOPDIR}/zbstudio/MANIFEST-bin-macos ${DATADIR} "^$")
+else()
+  # check the available Lua modules
+  check_lua_module(wx TRUE)
+  check_lua_module(socket TRUE)
+  check_lua_module(copas ${USE_SYSTEM_COPAS})
+  check_lua_module(luainspect ${USE_SYSTEM_LUAINSPECT})
+  #check_lua_module(mobdebug ${USE_SYSTEM_MOBDEBUG})
+
+  # add user options to select between system-wide and bundled Lua modules
+  add_system_lua_module_option(copas)
+  add_system_lua_module_option(luainspect)
+  #add_system_lua_module_option(mobdebug)
+
+  # setup the data directory
+  set(DATADIR share/zbstudio)
+
+  # install IDE shell script
+  set(IDE_DATADIR "${CMAKE_INSTALL_PREFIX}/${DATADIR}")
+  configure_file(${TOPDIR}/zbstudio/zbstudio.in "${CMAKE_BINARY_DIR}/zbstudio")
+  install(PROGRAMS "${CMAKE_BINARY_DIR}/zbstudio" DESTINATION bin)
+
+  # install bundled Lua modules
+  if(NOT USE_SYSTEM_COPAS)
+    install(DIRECTORY ${TOPDIR}/lualibs/copas ${TOPDIR}/lualibs/coxpcall DESTINATION ${DATADIR}/lualibs)
+  endif()
+  if(NOT USE_SYSTEM_LUAINSPECT)
+    install(DIRECTORY ${TOPDIR}/lualibs/luainspect ${TOPDIR}/lualibs/metalua DESTINATION ${DATADIR}/lualibs)
+  endif()
+  if(NOT USE_SYSTEM_MOBDEBUG)
+    install(DIRECTORY ${TOPDIR}/lualibs/mobdebug DESTINATION ${DATADIR}/lualibs)
+  endif()
+
+  # install .desktop file and hicolor icon theme
+  install(DIRECTORY ${TOPDIR}/zbstudio/res/icons/ DESTINATION share/icons/hicolor)
+  install(FILES ${TOPDIR}/zbstudio/res/zbstudio.desktop DESTINATION share/applications)
+
+  # install miscellaneous documentation files
+  install(FILES ${TOPDIR}/CHANGELOG.md ${TOPDIR}/LICENSE ${TOPDIR}/README.md DESTINATION share/doc/zbstudio)
+
+  # install files from manifest
+  install_from_manifest(FILES ${TOPDIR}/zbstudio/MANIFEST ${DATADIR} "^(CHANGELOG.md|LICENSE|README.md)$|^lualibs/")
+endif()

build/build-linux-prep-deb.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+
+# this script installs prerequisites to build binary files on Linux with deb
+
+sudo apt-get install git-core
+sudo apt-get install g++
+sudo apt-get install subversion
+sudo apt-get install libgtk2.0-dev
+
+# install cmake as wxwidgets needs 2.8.4+ but "sudo apt-get install cmake" 
+# only installs 2.8.0 on some systems (like Ubuntu 10.4)
+ mkdir build-cmake
+ cd build-cmake
+ wget http://www.cmake.org/files/v2.8/cmake-2.8.10.2.tar.gz
+ gunzip cmake-2.8.10.2.tar.gz 
+ tar xvf cmake-2.8.10.2.tar 
+ cd cmake-2.8.10.2
+ ./bootstrap
+ make
+ sudo make install
+ cd ../..
+ rm -rf build-cmake