初始化

cocos2d-x/cocos/scripting/js-bindings/auto/api/jsb_cocos2dx_audioengine_auto_api.js

@@ -0,0 +1,343 @@
+/**
+ * @module audioengine
+ */
+var jsb = jsb || {};
+
+/**
+ * @class AudioProfile
+ */
+jsb.AudioProfile = {
+
+/**
+ * @method AudioProfile
+ * @constructor
+ */
+AudioProfile : function (
+)
+{
+},
+
+};
+
+/**
+ * @class AudioEngine
+ */
+jsb.AudioEngine = {
+
+/**
+ * @method lazyInit
+ * @return {bool}
+ */
+lazyInit : function (
+)
+{
+    return false;
+},
+
+/**
+ * @method setCurrentTime
+ * @param {int} arg0
+ * @param {float} arg1
+ * @return {bool}
+ */
+setCurrentTime : function (
+int, 
+float 
+)
+{
+    return false;
+},
+
+/**
+ * @method getVolume
+ * @param {int} arg0
+ * @return {float}
+ */
+getVolume : function (
+int 
+)
+{
+    return 0;
+},
+
+/**
+ * @method uncache
+ * @param {String} arg0
+ */
+uncache : function (
+str 
+)
+{
+},
+
+/**
+ * @method resumeAll
+ */
+resumeAll : function (
+)
+{
+},
+
+/**
+ * @method stopAll
+ */
+stopAll : function (
+)
+{
+},
+
+/**
+ * @method pause
+ * @param {int} arg0
+ */
+pause : function (
+int 
+)
+{
+},
+
+/**
+ * @method end
+ */
+end : function (
+)
+{
+},
+
+/**
+ * @method getMaxAudioInstance
+ * @return {int}
+ */
+getMaxAudioInstance : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method isEnabled
+ * @return {bool}
+ */
+isEnabled : function (
+)
+{
+    return false;
+},
+
+/**
+ * @method getDurationFromFile
+ * @param {String} arg0
+ * @return {float}
+ */
+getDurationFromFile : function (
+str 
+)
+{
+    return 0;
+},
+
+/**
+ * @method getCurrentTime
+ * @param {int} arg0
+ * @return {float}
+ */
+getCurrentTime : function (
+int 
+)
+{
+    return 0;
+},
+
+/**
+ * @method setMaxAudioInstance
+ * @param {int} arg0
+ * @return {bool}
+ */
+setMaxAudioInstance : function (
+int 
+)
+{
+    return false;
+},
+
+/**
+ * @method isLoop
+ * @param {int} arg0
+ * @return {bool}
+ */
+isLoop : function (
+int 
+)
+{
+    return false;
+},
+
+/**
+ * @method pauseAll
+ */
+pauseAll : function (
+)
+{
+},
+
+/**
+ * @method uncacheAll
+ */
+uncacheAll : function (
+)
+{
+},
+
+/**
+ * @method setVolume
+ * @param {int} arg0
+ * @param {float} arg1
+ */
+setVolume : function (
+int, 
+float 
+)
+{
+},
+
+/**
+ * @method preload
+* @param {String|String} str
+* @param {function} func
+*/
+preload : function(
+str,
+func 
+)
+{
+},
+
+/**
+ * @method setEnabled
+ * @param {bool} arg0
+ */
+setEnabled : function (
+bool 
+)
+{
+},
+
+/**
+ * @method play2d
+ * @param {String} arg0
+ * @param {bool} arg1
+ * @param {float} arg2
+ * @param {cc.AudioProfile} arg3
+ * @return {int}
+ */
+play2d : function (
+str, 
+bool, 
+float, 
+audioprofile 
+)
+{
+    return 0;
+},
+
+/**
+ * @method getState
+ * @param {int} arg0
+ * @return {cc.AudioEngine::AudioState}
+ */
+getState : function (
+int 
+)
+{
+    return 0;
+},
+
+/**
+ * @method resume
+ * @param {int} arg0
+ */
+resume : function (
+int 
+)
+{
+},
+
+/**
+ * @method stop
+ * @param {int} arg0
+ */
+stop : function (
+int 
+)
+{
+},
+
+/**
+ * @method getDuration
+ * @param {int} arg0
+ * @return {float}
+ */
+getDuration : function (
+int 
+)
+{
+    return 0;
+},
+
+/**
+ * @method setLoop
+ * @param {int} arg0
+ * @param {bool} arg1
+ */
+setLoop : function (
+int, 
+bool 
+)
+{
+},
+
+/**
+ * @method getDefaultProfile
+ * @return {cc.AudioProfile}
+ */
+getDefaultProfile : function (
+)
+{
+    return cc.AudioProfile;
+},
+
+/**
+ * @method setFinishCallback
+ * @param {int} arg0
+ * @param {function} arg1
+ */
+setFinishCallback : function (
+int, 
+func 
+)
+{
+},
+
+/**
+ * @method getProfile
+* @param {String|int} str
+* @return {cc.AudioProfile|cc.AudioProfile}
+*/
+getProfile : function(
+int 
+)
+{
+    return cc.AudioProfile;
+},
+
+/**
+ * @method getPlayingAudioCount
+ * @return {int}
+ */
+getPlayingAudioCount : function (
+)
+{
+    return 0;
+},
+
+};

cocos2d-x/cocos/scripting/js-bindings/auto/api/jsb_cocos2dx_editor_support_auto_api.js

@@ -0,0 +1,184 @@
+/**
+ * @module cocos2dx_editor_support
+ */
+var middleware = middleware || {};
+
+/**
+ * @class Texture2D
+ */
+middleware.Texture2D = {
+
+/**
+ * @method getRealTextureIndex
+ * @return {int}
+ */
+getRealTextureIndex : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method setTexParamCallback
+ * @param {function} arg0
+ */
+setTexParamCallback : function (
+func 
+)
+{
+},
+
+/**
+ * @method setPixelsHigh
+ * @param {int} arg0
+ */
+setPixelsHigh : function (
+int 
+)
+{
+},
+
+/**
+ * @method getNativeTexture
+ * @return {cc.renderer::Texture}
+ */
+getNativeTexture : function (
+)
+{
+    return cc.renderer::Texture;
+},
+
+/**
+ * @method setPixelsWide
+ * @param {int} arg0
+ */
+setPixelsWide : function (
+int 
+)
+{
+},
+
+/**
+ * @method getPixelsHigh
+ * @return {int}
+ */
+getPixelsHigh : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method getPixelsWide
+ * @return {int}
+ */
+getPixelsWide : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method setRealTextureIndex
+ * @param {int} arg0
+ */
+setRealTextureIndex : function (
+int 
+)
+{
+},
+
+/**
+ * @method setNativeTexture
+ * @param {cc.renderer::Texture} arg0
+ */
+setNativeTexture : function (
+texture 
+)
+{
+},
+
+/**
+ * @method setTexParameters
+ * @param {cc.middleware::Texture2D::_TexParams} arg0
+ */
+setTexParameters : function (
+_texparams 
+)
+{
+},
+
+/**
+ * @method Texture2D
+ * @constructor
+ */
+Texture2D : function (
+)
+{
+},
+
+};
+
+/**
+ * @class MiddlewareManager
+ */
+middleware.MiddlewareManager = {
+
+/**
+ * @method render
+ * @param {float} arg0
+ */
+render : function (
+float 
+)
+{
+},
+
+/**
+ * @method update
+ * @param {float} arg0
+ */
+update : function (
+float 
+)
+{
+},
+
+/**
+ * @method destroyInstance
+ */
+destroyInstance : function (
+)
+{
+},
+
+/**
+ * @method generateModuleID
+ * @return {unsigned char}
+ */
+generateModuleID : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method getInstance
+ * @return {cc.middleware::MiddlewareManager}
+ */
+getInstance : function (
+)
+{
+    return cc.middleware::MiddlewareManager;
+},
+
+/**
+ * @method MiddlewareManager
+ * @constructor
+ */
+MiddlewareManager : function (
+)
+{
+},
+
+};

cocos2d-x/cocos/scripting/js-bindings/auto/api/jsb_cocos2dx_extension_auto_api.js

@@ -0,0 +1,548 @@
+/**
+ * @module extension
+ */
+var jsb = jsb || {};
+
+/**
+ * @class EventAssetsManagerEx
+ */
+jsb.EventAssetsManager = {
+
+/**
+ * @method getAssetsManagerEx
+ * @return {cc.AssetsManagerEx}
+ */
+getAssetsManagerEx : function (
+)
+{
+    return cc.AssetsManagerEx;
+},
+
+/**
+ * @method getDownloadedFiles
+ * @return {int}
+ */
+getDownloadedFiles : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method getTotalFiles
+ * @return {int}
+ */
+getTotalFiles : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method getAssetId
+ * @return {String}
+ */
+getAssetId : function (
+)
+{
+    return ;
+},
+
+/**
+ * @method getTotalBytes
+ * @return {double}
+ */
+getTotalBytes : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method getCURLECode
+ * @return {int}
+ */
+getCURLECode : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method getMessage
+ * @return {String}
+ */
+getMessage : function (
+)
+{
+    return ;
+},
+
+/**
+ * @method getCURLMCode
+ * @return {int}
+ */
+getCURLMCode : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method getDownloadedBytes
+ * @return {double}
+ */
+getDownloadedBytes : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method getPercentByFile
+ * @return {float}
+ */
+getPercentByFile : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method getEventCode
+ * @return {cc.EventAssetsManagerEx::EventCode}
+ */
+getEventCode : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method getPercent
+ * @return {float}
+ */
+getPercent : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method isResuming
+ * @return {bool}
+ */
+isResuming : function (
+)
+{
+    return false;
+},
+
+/**
+ * @method EventAssetsManagerEx
+ * @constructor
+ * @param {String} arg0
+ * @param {cc.AssetsManagerEx} arg1
+ * @param {cc.EventAssetsManagerEx::EventCode} arg2
+ * @param {String} arg3
+ * @param {String} arg4
+ * @param {int} arg5
+ * @param {int} arg6
+ */
+EventAssetsManagerEx : function (
+str, 
+assetsmanagerex, 
+eventcode, 
+str, 
+str, 
+int, 
+int 
+)
+{
+},
+
+};
+
+/**
+ * @class Manifest
+ */
+jsb.Manifest = {
+
+/**
+ * @method getManifestRoot
+ * @return {String}
+ */
+getManifestRoot : function (
+)
+{
+    return ;
+},
+
+/**
+ * @method setUpdating
+ * @param {bool} arg0
+ */
+setUpdating : function (
+bool 
+)
+{
+},
+
+/**
+ * @method getManifestFileUrl
+ * @return {String}
+ */
+getManifestFileUrl : function (
+)
+{
+    return ;
+},
+
+/**
+ * @method isVersionLoaded
+ * @return {bool}
+ */
+isVersionLoaded : function (
+)
+{
+    return false;
+},
+
+/**
+ * @method parseFile
+ * @param {String} arg0
+ */
+parseFile : function (
+str 
+)
+{
+},
+
+/**
+ * @method isLoaded
+ * @return {bool}
+ */
+isLoaded : function (
+)
+{
+    return false;
+},
+
+/**
+ * @method getPackageUrl
+ * @return {String}
+ */
+getPackageUrl : function (
+)
+{
+    return ;
+},
+
+/**
+ * @method isUpdating
+ * @return {bool}
+ */
+isUpdating : function (
+)
+{
+    return false;
+},
+
+/**
+ * @method getVersion
+ * @return {String}
+ */
+getVersion : function (
+)
+{
+    return ;
+},
+
+/**
+ * @method parseJSONString
+ * @param {String} arg0
+ * @param {String} arg1
+ */
+parseJSONString : function (
+str, 
+str 
+)
+{
+},
+
+/**
+ * @method getVersionFileUrl
+ * @return {String}
+ */
+getVersionFileUrl : function (
+)
+{
+    return ;
+},
+
+/**
+ * @method getSearchPaths
+ * @return {Array}
+ */
+getSearchPaths : function (
+)
+{
+    return new Array();
+},
+
+/**
+ * @method Manifest
+ * @constructor
+* @param {String|String} str
+* @param {String} str
+*/
+Manifest : function(
+str,
+str 
+)
+{
+},
+
+};
+
+/**
+ * @class AssetsManagerEx
+ */
+jsb.AssetsManager = {
+
+/**
+ * @method getDownloadedFiles
+ * @return {int}
+ */
+getDownloadedFiles : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method setEventCallback
+ * @param {function} arg0
+ */
+setEventCallback : function (
+func 
+)
+{
+},
+
+/**
+ * @method downloadFailedAssets
+ */
+downloadFailedAssets : function (
+)
+{
+},
+
+/**
+ * @method getTotalFiles
+ * @return {int}
+ */
+getTotalFiles : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method checkUpdate
+ */
+checkUpdate : function (
+)
+{
+},
+
+/**
+ * @method loadLocalManifest
+* @param {String|cc.Manifest} str
+* @param {String} str
+* @return {bool|bool}
+*/
+loadLocalManifest : function(
+manifest,
+str 
+)
+{
+    return false;
+},
+
+/**
+ * @method setMaxConcurrentTask
+ * @param {int} arg0
+ */
+setMaxConcurrentTask : function (
+int 
+)
+{
+},
+
+/**
+ * @method getLocalManifest
+ * @return {cc.Manifest}
+ */
+getLocalManifest : function (
+)
+{
+    return cc.Manifest;
+},
+
+/**
+ * @method getRemoteManifest
+ * @return {cc.Manifest}
+ */
+getRemoteManifest : function (
+)
+{
+    return cc.Manifest;
+},
+
+/**
+ * @method cancelUpdate
+ */
+cancelUpdate : function (
+)
+{
+},
+
+/**
+ * @method isResuming
+ * @return {bool}
+ */
+isResuming : function (
+)
+{
+    return false;
+},
+
+/**
+ * @method getState
+ * @return {cc.AssetsManagerEx::State}
+ */
+getState : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method getMaxConcurrentTask
+ * @return {int}
+ */
+getMaxConcurrentTask : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method setVersionCompareHandle
+ * @param {function} arg0
+ */
+setVersionCompareHandle : function (
+func 
+)
+{
+},
+
+/**
+ * @method getTotalBytes
+ * @return {double}
+ */
+getTotalBytes : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method setVerifyCallback
+ * @param {function} arg0
+ */
+setVerifyCallback : function (
+func 
+)
+{
+},
+
+/**
+ * @method getStoragePath
+ * @return {String}
+ */
+getStoragePath : function (
+)
+{
+    return ;
+},
+
+/**
+ * @method update
+ */
+update : function (
+)
+{
+},
+
+/**
+ * @method getDownloadedBytes
+ * @return {double}
+ */
+getDownloadedBytes : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method prepareUpdate
+ */
+prepareUpdate : function (
+)
+{
+},
+
+/**
+ * @method loadRemoteManifest
+ * @param {cc.Manifest} arg0
+ * @return {bool}
+ */
+loadRemoteManifest : function (
+manifest 
+)
+{
+    return false;
+},
+
+/**
+ * @method create
+ * @param {String} arg0
+ * @param {String} arg1
+ * @return {cc.AssetsManagerEx}
+ */
+create : function (
+str, 
+str 
+)
+{
+    return cc.AssetsManagerEx;
+},
+
+/**
+ * @method AssetsManagerEx
+ * @constructor
+* @param {String|String} str
+* @param {String|String} str
+* @param {function} func
+*/
+AssetsManagerEx : function(
+str,
+str,
+func 
+)
+{
+},
+
+};

cocos2d-x/cocos/scripting/js-bindings/auto/api/jsb_cocos2dx_network_auto_api.js

@@ -0,0 +1,32 @@
+/**
+ * @module network
+ */
+var jsb = jsb || {};
+
+/**
+ * @class Downloader
+ */
+jsb.Downloader = {
+
+/**
+ * @method setOnTaskProgress
+ * @param {function} arg0
+ */
+setOnTaskProgress : function (
+func 
+)
+{
+},
+
+/**
+ * @method Downloader
+ * @constructor
+* @param {cc.network::DownloaderHints} downloaderhints
+*/
+Downloader : function(
+downloaderhints 
+)
+{
+},
+
+};

cocos2d-x/cocos/scripting/js-bindings/auto/api/jsb_cocos2dx_particle_auto_api.js

@@ -0,0 +1,258 @@
+/**
+ * @module cocos2dx_particle
+ */
+var middleware = middleware || {};
+
+/**
+ * @class ParticleSimulator
+ */
+middleware.ParticleSimulator = {
+
+/**
+ * @method setGravity
+ * @param {float} arg0
+ * @param {float} arg1
+ * @param {float} arg2
+ */
+setGravity : function (
+float, 
+float, 
+float 
+)
+{
+},
+
+/**
+ * @method render
+ * @param {float} arg0
+ */
+render : function (
+float 
+)
+{
+},
+
+/**
+ * @method setSourcePos
+ * @param {float} arg0
+ * @param {float} arg1
+ * @param {float} arg2
+ */
+setSourcePos : function (
+float, 
+float, 
+float 
+)
+{
+},
+
+/**
+ * @method onEnable
+ */
+onEnable : function (
+)
+{
+},
+
+/**
+ * @method setEffect
+ * @param {cc.renderer::EffectVariant} arg0
+ */
+setEffect : function (
+effectvariant 
+)
+{
+},
+
+/**
+ * @method setPosVar
+ * @param {float} arg0
+ * @param {float} arg1
+ * @param {float} arg2
+ */
+setPosVar : function (
+float, 
+float, 
+float 
+)
+{
+},
+
+/**
+ * @method setEndColorVar
+ * @param {unsigned char} arg0
+ * @param {unsigned char} arg1
+ * @param {unsigned char} arg2
+ * @param {unsigned char} arg3
+ */
+setEndColorVar : function (
+char, 
+char, 
+char, 
+char 
+)
+{
+},
+
+/**
+ * @method getParticleCount
+ * @return {unsigned int}
+ */
+getParticleCount : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method setStartColorVar
+ * @param {unsigned char} arg0
+ * @param {unsigned char} arg1
+ * @param {unsigned char} arg2
+ * @param {unsigned char} arg3
+ */
+setStartColorVar : function (
+char, 
+char, 
+char, 
+char 
+)
+{
+},
+
+/**
+ * @method emitParticle
+ * @param {vec3_object} arg0
+ */
+emitParticle : function (
+vec3 
+)
+{
+},
+
+/**
+ * @method stop
+ */
+stop : function (
+)
+{
+},
+
+/**
+ * @method update
+ * @param {float} arg0
+ */
+update : function (
+float 
+)
+{
+},
+
+/**
+ * @method active
+ * @return {bool}
+ */
+active : function (
+)
+{
+    return false;
+},
+
+/**
+ * @method updateUVs
+ * @param {Array} arg0
+ */
+updateUVs : function (
+array 
+)
+{
+},
+
+/**
+ * @method setStartColor
+ * @param {unsigned char} arg0
+ * @param {unsigned char} arg1
+ * @param {unsigned char} arg2
+ * @param {unsigned char} arg3
+ */
+setStartColor : function (
+char, 
+char, 
+char, 
+char 
+)
+{
+},
+
+/**
+ * @method reset
+ */
+reset : function (
+)
+{
+},
+
+/**
+ * @method onDisable
+ */
+onDisable : function (
+)
+{
+},
+
+/**
+ * @method bindNodeProxy
+ * @param {cc.renderer::NodeProxy} arg0
+ */
+bindNodeProxy : function (
+nodeproxy 
+)
+{
+},
+
+/**
+ * @method setEndColor
+ * @param {unsigned char} arg0
+ * @param {unsigned char} arg1
+ * @param {unsigned char} arg2
+ * @param {unsigned char} arg3
+ */
+setEndColor : function (
+char, 
+char, 
+char, 
+char 
+)
+{
+},
+
+/**
+ * @method setFinishedCallback
+ * @param {function} arg0
+ */
+setFinishedCallback : function (
+func 
+)
+{
+},
+
+/**
+ * @method setStopCallback
+ * @param {function} arg0
+ */
+setStopCallback : function (
+func 
+)
+{
+},
+
+/**
+ * @method ParticleSimulator
+ * @constructor
+ */
+ParticleSimulator : function (
+)
+{
+},
+
+};

cocos2d-x/cocos/scripting/js-bindings/auto/api/jsb_gfx_auto_api.js

@@ -0,0 +1,841 @@
+/**
+ * @module gfx
+ */
+var gfx = gfx || {};
+
+/**
+ * @class GraphicsHandle
+ */
+gfx.GraphicsHandle = {
+
+/**
+ * @method getHandle
+ * @return {unsigned int}
+ */
+getHandle : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method GraphicsHandle
+ * @constructor
+ */
+GraphicsHandle : function (
+)
+{
+},
+
+};
+
+/**
+ * @class IndexBuffer
+ */
+gfx.IndexBuffer = {
+
+/**
+ * @method getUsage
+ * @return {cc.renderer::Usage}
+ */
+getUsage : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method setFormat
+ * @param {cc.renderer::IndexFormat} arg0
+ */
+setFormat : function (
+indexformat 
+)
+{
+},
+
+/**
+ * @method setCount
+ * @param {unsigned int} arg0
+ */
+setCount : function (
+int 
+)
+{
+},
+
+/**
+ * @method destroy
+ */
+destroy : function (
+)
+{
+},
+
+/**
+ * @method setUsage
+ * @param {cc.renderer::Usage} arg0
+ */
+setUsage : function (
+usage 
+)
+{
+},
+
+/**
+ * @method getCount
+ * @return {unsigned int}
+ */
+getCount : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method setBytesPerIndex
+ * @param {unsigned int} arg0
+ */
+setBytesPerIndex : function (
+int 
+)
+{
+},
+
+/**
+ * @method getBytes
+ * @return {unsigned int}
+ */
+getBytes : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method IndexBuffer
+ * @constructor
+ */
+IndexBuffer : function (
+)
+{
+},
+
+};
+
+/**
+ * @class VertexBuffer
+ */
+gfx.VertexBuffer = {
+
+/**
+ * @method getUsage
+ * @return {cc.renderer::Usage}
+ */
+getUsage : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method setCount
+ * @param {unsigned int} arg0
+ */
+setCount : function (
+int 
+)
+{
+},
+
+/**
+ * @method destroy
+ */
+destroy : function (
+)
+{
+},
+
+/**
+ * @method setUsage
+ * @param {cc.renderer::Usage} arg0
+ */
+setUsage : function (
+usage 
+)
+{
+},
+
+/**
+ * @method getCount
+ * @return {unsigned int}
+ */
+getCount : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method getBytes
+ * @return {unsigned int}
+ */
+getBytes : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method VertexBuffer
+ * @constructor
+ */
+VertexBuffer : function (
+)
+{
+},
+
+};
+
+/**
+ * @class DeviceGraphics
+ */
+gfx.Device = {
+
+/**
+ * @method setBlendFuncSeparate
+ * @param {cc.renderer::BlendFactor} arg0
+ * @param {cc.renderer::BlendFactor} arg1
+ * @param {cc.renderer::BlendFactor} arg2
+ * @param {cc.renderer::BlendFactor} arg3
+ */
+setBlendFuncSeparate : function (
+blendfactor, 
+blendfactor, 
+blendfactor, 
+blendfactor 
+)
+{
+},
+
+/**
+ * @method enableBlend
+ */
+enableBlend : function (
+)
+{
+},
+
+/**
+ * @method setPrimitiveType
+ * @param {cc.renderer::PrimitiveType} arg0
+ */
+setPrimitiveType : function (
+primitivetype 
+)
+{
+},
+
+/**
+ * @method setBlendEquationSeparate
+ * @param {cc.renderer::BlendOp} arg0
+ * @param {cc.renderer::BlendOp} arg1
+ */
+setBlendEquationSeparate : function (
+blendop, 
+blendop 
+)
+{
+},
+
+/**
+ * @method setIndexBuffer
+ * @param {cc.renderer::IndexBuffer} arg0
+ */
+setIndexBuffer : function (
+indexbuffer 
+)
+{
+},
+
+/**
+ * @method setProgram
+ * @param {cc.renderer::Program} arg0
+ */
+setProgram : function (
+program 
+)
+{
+},
+
+/**
+ * @method setFrameBuffer
+ * @param {cc.renderer::FrameBuffer} arg0
+ */
+setFrameBuffer : function (
+framebuffer 
+)
+{
+},
+
+/**
+ * @method setStencilFunc
+ * @param {cc.renderer::ComparisonFunc} arg0
+ * @param {int} arg1
+ * @param {unsigned int} arg2
+ */
+setStencilFunc : function (
+comparisonfunc, 
+int, 
+int 
+)
+{
+},
+
+/**
+ * @method setBlendColor
+* @param {unsigned char|unsigned int} char
+* @param {unsigned char} char
+* @param {unsigned char} char
+* @param {unsigned char} char
+*/
+setBlendColor : function(
+char,
+char,
+char,
+char 
+)
+{
+},
+
+/**
+ * @method setScissor
+ * @param {int} arg0
+ * @param {int} arg1
+ * @param {int} arg2
+ * @param {int} arg3
+ */
+setScissor : function (
+int, 
+int, 
+int, 
+int 
+)
+{
+},
+
+/**
+ * @method setVertexBuffer
+ * @param {int} arg0
+ * @param {cc.renderer::VertexBuffer} arg1
+ * @param {int} arg2
+ */
+setVertexBuffer : function (
+int, 
+vertexbuffer, 
+int 
+)
+{
+},
+
+/**
+ * @method enableDepthWrite
+ */
+enableDepthWrite : function (
+)
+{
+},
+
+/**
+ * @method getCapacity
+ * @return {cc.renderer::DeviceGraphics::Capacity}
+ */
+getCapacity : function (
+)
+{
+    return cc.renderer::DeviceGraphics::Capacity;
+},
+
+/**
+ * @method setStencilOpBack
+ * @param {cc.renderer::StencilOp} arg0
+ * @param {cc.renderer::StencilOp} arg1
+ * @param {cc.renderer::StencilOp} arg2
+ * @param {unsigned int} arg3
+ */
+setStencilOpBack : function (
+stencilop, 
+stencilop, 
+stencilop, 
+int 
+)
+{
+},
+
+/**
+ * @method setViewport
+ * @param {int} arg0
+ * @param {int} arg1
+ * @param {int} arg2
+ * @param {int} arg3
+ */
+setViewport : function (
+int, 
+int, 
+int, 
+int 
+)
+{
+},
+
+/**
+ * @method draw
+ * @param {unsigned int} arg0
+ * @param {int} arg1
+ */
+draw : function (
+int, 
+int 
+)
+{
+},
+
+/**
+ * @method setDepthFunc
+ * @param {cc.renderer::ComparisonFunc} arg0
+ */
+setDepthFunc : function (
+comparisonfunc 
+)
+{
+},
+
+/**
+ * @method enableDepthTest
+ */
+enableDepthTest : function (
+)
+{
+},
+
+/**
+ * @method resetDrawCalls
+ */
+resetDrawCalls : function (
+)
+{
+},
+
+/**
+ * @method getDrawCalls
+ * @return {unsigned int}
+ */
+getDrawCalls : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method setBlendEquation
+ * @param {cc.renderer::BlendOp} arg0
+ */
+setBlendEquation : function (
+blendop 
+)
+{
+},
+
+/**
+ * @method setStencilFuncFront
+ * @param {cc.renderer::ComparisonFunc} arg0
+ * @param {int} arg1
+ * @param {unsigned int} arg2
+ */
+setStencilFuncFront : function (
+comparisonfunc, 
+int, 
+int 
+)
+{
+},
+
+/**
+ * @method setStencilOpFront
+ * @param {cc.renderer::StencilOp} arg0
+ * @param {cc.renderer::StencilOp} arg1
+ * @param {cc.renderer::StencilOp} arg2
+ * @param {unsigned int} arg3
+ */
+setStencilOpFront : function (
+stencilop, 
+stencilop, 
+stencilop, 
+int 
+)
+{
+},
+
+/**
+ * @method setStencilFuncBack
+ * @param {cc.renderer::ComparisonFunc} arg0
+ * @param {int} arg1
+ * @param {unsigned int} arg2
+ */
+setStencilFuncBack : function (
+comparisonfunc, 
+int, 
+int 
+)
+{
+},
+
+/**
+ * @method setBlendFunc
+ * @param {cc.renderer::BlendFactor} arg0
+ * @param {cc.renderer::BlendFactor} arg1
+ */
+setBlendFunc : function (
+blendfactor, 
+blendfactor 
+)
+{
+},
+
+/**
+ * @method setCullMode
+ * @param {cc.renderer::CullMode} arg0
+ */
+setCullMode : function (
+cullmode 
+)
+{
+},
+
+/**
+ * @method setStencilOp
+ * @param {cc.renderer::StencilOp} arg0
+ * @param {cc.renderer::StencilOp} arg1
+ * @param {cc.renderer::StencilOp} arg2
+ * @param {unsigned int} arg3
+ */
+setStencilOp : function (
+stencilop, 
+stencilop, 
+stencilop, 
+int 
+)
+{
+},
+
+/**
+ * @method enableStencilTest
+ */
+enableStencilTest : function (
+)
+{
+},
+
+/**
+ * @method destroy
+ */
+destroy : function (
+)
+{
+},
+
+/**
+ * @method getInstance
+ * @return {cc.renderer::DeviceGraphics}
+ */
+getInstance : function (
+)
+{
+    return cc.renderer::DeviceGraphics;
+},
+
+};
+
+/**
+ * @class FrameBuffer
+ */
+gfx.FrameBuffer = {
+
+/**
+ * @method getHeight
+ * @return {int}
+ */
+getHeight : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method getWidth
+ * @return {int}
+ */
+getWidth : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method destroy
+ */
+destroy : function (
+)
+{
+},
+
+/**
+ * @method FrameBuffer
+ * @constructor
+ */
+FrameBuffer : function (
+)
+{
+},
+
+};
+
+/**
+ * @class RenderTarget
+ */
+gfx.RenderTarget = {
+
+};
+
+/**
+ * @class RenderBuffer
+ */
+gfx.RenderBuffer = {
+
+/**
+ * @method init
+ * @param {cc.renderer::DeviceGraphics} arg0
+ * @param {cc.renderer::RenderBuffer::Format} arg1
+ * @param {unsigned short} arg2
+ * @param {unsigned short} arg3
+ * @return {bool}
+ */
+init : function (
+devicegraphics, 
+format, 
+short, 
+short 
+)
+{
+    return false;
+},
+
+/**
+ * @method update
+ * @param {unsigned short} arg0
+ * @param {unsigned short} arg1
+ * @return {bool}
+ */
+update : function (
+short, 
+short 
+)
+{
+    return false;
+},
+
+/**
+ * @method create
+ * @param {cc.renderer::DeviceGraphics} arg0
+ * @param {cc.renderer::RenderBuffer::Format} arg1
+ * @param {unsigned short} arg2
+ * @param {unsigned short} arg3
+ * @return {cc.renderer::RenderBuffer}
+ */
+create : function (
+devicegraphics, 
+format, 
+short, 
+short 
+)
+{
+    return cc.renderer::RenderBuffer;
+},
+
+/**
+ * @method RenderBuffer
+ * @constructor
+ */
+RenderBuffer : function (
+)
+{
+},
+
+};
+
+/**
+ * @class Texture
+ */
+gfx.Texture = {
+
+/**
+ * @method getWidth
+ * @return {unsigned short}
+ */
+getWidth : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method setAlphaAtlas
+ * @param {bool} arg0
+ */
+setAlphaAtlas : function (
+bool 
+)
+{
+},
+
+/**
+ * @method getHeight
+ * @return {unsigned short}
+ */
+getHeight : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method isAlphaAtlas
+ * @return {bool}
+ */
+isAlphaAtlas : function (
+)
+{
+    return false;
+},
+
+/**
+ * @method getTarget
+ * @return {unsigned int}
+ */
+getTarget : function (
+)
+{
+    return 0;
+},
+
+};
+
+/**
+ * @class Texture2D
+ */
+gfx.Texture2D = {
+
+/**
+ * @method updateImage
+ * @param {cc.renderer::Texture::ImageOption} arg0
+ */
+updateImage : function (
+imageoption 
+)
+{
+},
+
+/**
+ * @method init
+ * @param {cc.renderer::DeviceGraphics} arg0
+ * @param {cc.renderer::Texture::Options} arg1
+ * @return {bool}
+ */
+init : function (
+devicegraphics, 
+options 
+)
+{
+    return false;
+},
+
+/**
+ * @method updateSubImage
+ * @param {cc.renderer::Texture::SubImageOption} arg0
+ */
+updateSubImage : function (
+subimageoption 
+)
+{
+},
+
+/**
+ * @method update
+ * @param {cc.renderer::Texture::Options} arg0
+ */
+update : function (
+options 
+)
+{
+},
+
+/**
+ * @method Texture2D
+ * @constructor
+ */
+Texture2D : function (
+)
+{
+},
+
+};
+
+/**
+ * @class Program
+ */
+gfx.Program = {
+
+/**
+ * @method getID
+ * @return {unsigned int}
+ */
+getID : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method init
+ * @param {cc.renderer::DeviceGraphics} arg0
+ * @param {char} arg1
+ * @param {char} arg2
+ * @return {bool}
+ */
+init : function (
+devicegraphics, 
+char, 
+char 
+)
+{
+    return false;
+},
+
+/**
+ * @method link
+ */
+link : function (
+)
+{
+},
+
+/**
+ * @method Program
+ * @constructor
+ */
+Program : function (
+)
+{
+},
+
+};

cocos2d-x/cocos/scripting/js-bindings/auto/api/jsb_video_auto_api.js

@@ -0,0 +1,238 @@
+/**
+ * @module video
+ */
+var jsb = jsb || {};
+
+/**
+ * @class VideoPlayer
+ */
+jsb.VideoPlayer = {
+
+/**
+ * @method setFullScreenEnabled
+ * @param {bool} arg0
+ */
+setFullScreenEnabled : function (
+bool 
+)
+{
+},
+
+/**
+ * @method getFrameWidth
+ * @return {int}
+ */
+getFrameWidth : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method duration
+ * @return {float}
+ */
+duration : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method pause
+ */
+pause : function (
+)
+{
+},
+
+/**
+ * @method getFrame
+ */
+getFrame : function (
+)
+{
+},
+
+/**
+ * @method setShowRawFrame
+ * @param {bool} arg0
+ */
+setShowRawFrame : function (
+bool 
+)
+{
+},
+
+/**
+ * @method onPlayEvent
+ * @param {int} arg0
+ */
+onPlayEvent : function (
+int 
+)
+{
+},
+
+/**
+ * @method addEventListener
+ * @param {String} arg0
+ * @param {function} arg1
+ */
+addEventListener : function (
+str, 
+func 
+)
+{
+},
+
+/**
+ * @method seekTo
+ * @param {float} arg0
+ */
+seekTo : function (
+float 
+)
+{
+},
+
+/**
+ * @method play
+ */
+play : function (
+)
+{
+},
+
+/**
+ * @method getFrameHeight
+ * @return {int}
+ */
+getFrameHeight : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method stop
+ */
+stop : function (
+)
+{
+},
+
+/**
+ * @method setURL
+ * @param {String} arg0
+ */
+setURL : function (
+str 
+)
+{
+},
+
+/**
+ * @method update
+ */
+update : function (
+)
+{
+},
+
+/**
+ * @method pushFrameDataToTexture2D
+ * @param {cc.renderer::Texture} arg0
+ */
+pushFrameDataToTexture2D : function (
+texture 
+)
+{
+},
+
+/**
+ * @method isKeepAspectRatioEnabled
+ * @return {bool}
+ */
+isKeepAspectRatioEnabled : function (
+)
+{
+    return false;
+},
+
+/**
+ * @method getFrameChannel
+ * @return {int}
+ */
+getFrameChannel : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method getVideoTexDataSize
+ * @return {int}
+ */
+getVideoTexDataSize : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method setKeepAspectRatioEnabled
+ * @param {bool} arg0
+ */
+setKeepAspectRatioEnabled : function (
+bool 
+)
+{
+},
+
+/**
+ * @method currentTime
+ * @return {float}
+ */
+currentTime : function (
+)
+{
+    return 0;
+},
+
+/**
+ * @method setFrame
+ * @param {float} arg0
+ * @param {float} arg1
+ * @param {float} arg2
+ * @param {float} arg3
+ */
+setFrame : function (
+float, 
+float, 
+float, 
+float 
+)
+{
+},
+
+/**
+ * @method setVisible
+ * @param {bool} arg0
+ */
+setVisible : function (
+bool 
+)
+{
+},
+
+/**
+ * @method VideoPlayer
+ * @constructor
+ */
+VideoPlayer : function (
+)
+{
+},
+
+};

cocos2d-x/cocos/scripting/js-bindings/auto/api/jsb_webview_auto_api.js

@@ -0,0 +1,286 @@
+/**
+ * @module webview
+ */
+var jsb = jsb || {};
+
+/**
+ * @class WebView
+ */
+jsb.WebView = {
+
+/**
+ * @method setOnShouldStartLoading
+ * @param {function} arg0
+ */
+setOnShouldStartLoading : function (
+func 
+)
+{
+},
+
+/**
+ * @method setOnDidFailLoading
+ * @param {function} arg0
+ */
+setOnDidFailLoading : function (
+func 
+)
+{
+},
+
+/**
+ * @method canGoBack
+ * @return {bool}
+ */
+canGoBack : function (
+)
+{
+    return false;
+},
+
+/**
+ * @method loadHTMLString
+ * @param {String} arg0
+ * @param {String} arg1
+ */
+loadHTMLString : function (
+str, 
+str 
+)
+{
+},
+
+/**
+ * @method goForward
+ */
+goForward : function (
+)
+{
+},
+
+/**
+ * @method goBack
+ */
+goBack : function (
+)
+{
+},
+
+/**
+ * @method setScalesPageToFit
+ * @param {bool} arg0
+ */
+setScalesPageToFit : function (
+bool 
+)
+{
+},
+
+/**
+ * @method getOnDidFailLoading
+ * @return {function}
+ */
+getOnDidFailLoading : function (
+)
+{
+    return std::function<void (cocos2d::WebView , std::string&)>;
+},
+
+/**
+ * @method loadFile
+ * @param {String} arg0
+ */
+loadFile : function (
+str 
+)
+{
+},
+
+/**
+ * @method loadURL
+ * @param {String} arg0
+ */
+loadURL : function (
+str 
+)
+{
+},
+
+/**
+ * @method setBounces
+ * @param {bool} arg0
+ */
+setBounces : function (
+bool 
+)
+{
+},
+
+/**
+ * @method evaluateJS
+ * @param {String} arg0
+ */
+evaluateJS : function (
+str 
+)
+{
+},
+
+/**
+ * @method setOnJSCallback
+ * @param {function} arg0
+ */
+setOnJSCallback : function (
+func 
+)
+{
+},
+
+/**
+ * @method setBackgroundTransparent
+ * @param {bool} arg0
+ */
+setBackgroundTransparent : function (
+bool 
+)
+{
+},
+
+/**
+ * @method getOnJSCallback
+ * @return {function}
+ */
+getOnJSCallback : function (
+)
+{
+    return std::function<void (cocos2d::WebView , std::string&)>;
+},
+
+/**
+ * @method canGoForward
+ * @return {bool}
+ */
+canGoForward : function (
+)
+{
+    return false;
+},
+
+/**
+ * @method getOnShouldStartLoading
+ * @return {function}
+ */
+getOnShouldStartLoading : function (
+)
+{
+    return std::function<bool (cocos2d::WebView , std::string&)>;
+},
+
+/**
+ * @method stopLoading
+ */
+stopLoading : function (
+)
+{
+},
+
+/**
+ * @method setFrame
+ * @param {float} arg0
+ * @param {float} arg1
+ * @param {float} arg2
+ * @param {float} arg3
+ */
+setFrame : function (
+float, 
+float, 
+float, 
+float 
+)
+{
+},
+
+/**
+ * @method setVisible
+ * @param {bool} arg0
+ */
+setVisible : function (
+bool 
+)
+{
+},
+
+/**
+ * @method reload
+ */
+reload : function (
+)
+{
+},
+
+/**
+ * @method loadData
+ * @param {cc.Data} arg0
+ * @param {String} arg1
+ * @param {String} arg2
+ * @param {String} arg3
+ */
+loadData : function (
+data, 
+str, 
+str, 
+str 
+)
+{
+},
+
+/**
+ * @method setJavascriptInterfaceScheme
+ * @param {String} arg0
+ */
+setJavascriptInterfaceScheme : function (
+str 
+)
+{
+},
+
+/**
+ * @method setOnDidFinishLoading
+ * @param {function} arg0
+ */
+setOnDidFinishLoading : function (
+func 
+)
+{
+},
+
+/**
+ * @method getOnDidFinishLoading
+ * @return {function}
+ */
+getOnDidFinishLoading : function (
+)
+{
+    return std::function<void (cocos2d::WebView , std::string&)>;
+},
+
+/**
+ * @method create
+ * @return {cc.WebView}
+ */
+create : function (
+)
+{
+    return cc.WebView;
+},
+
+/**
+ * @method WebView
+ * @constructor
+ */
+WebView : function (
+)
+{
+},
+
+};

cocos2d-x/cocos/scripting/js-bindings/auto/jsb_cocos2dx_audioengine_auto.cpp

@@ -0,0 +1,827 @@
+#include "scripting/js-bindings/auto/jsb_cocos2dx_audioengine_auto.hpp"
+#if (USE_AUDIO > 0) && (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID || CC_TARGET_PLATFORM == CC_PLATFORM_IOS || CC_TARGET_PLATFORM == CC_PLATFORM_MAC || CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)
+#include "scripting/js-bindings/manual/jsb_conversions.hpp"
+#include "scripting/js-bindings/manual/jsb_global.h"
+#include "audio/include/AudioEngine.h"
+
+se::Object* __jsb_cocos2d_AudioProfile_proto = nullptr;
+se::Class* __jsb_cocos2d_AudioProfile_class = nullptr;
+
+static bool js_audioengine_AudioProfile_get_name(se::State& s)
+{
+    cocos2d::AudioProfile* cobj = (cocos2d::AudioProfile*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_audioengine_AudioProfile_get_name : Invalid Native Object");
+
+    CC_UNUSED bool ok = true;
+    se::Value jsret;
+    ok &= std_string_to_seval(cobj->name, &jsret);
+    s.rval() = jsret;
+    return true;
+}
+SE_BIND_PROP_GET(js_audioengine_AudioProfile_get_name)
+
+static bool js_audioengine_AudioProfile_set_name(se::State& s)
+{
+    const auto& args = s.args();
+    cocos2d::AudioProfile* cobj = (cocos2d::AudioProfile*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_audioengine_AudioProfile_set_name : Invalid Native Object");
+
+    CC_UNUSED bool ok = true;
+    std::string arg0;
+    ok &= seval_to_std_string(args[0], &arg0);
+    SE_PRECONDITION2(ok, false, "js_audioengine_AudioProfile_set_name : Error processing new value");
+    cobj->name = arg0;
+    return true;
+}
+SE_BIND_PROP_SET(js_audioengine_AudioProfile_set_name)
+
+static bool js_audioengine_AudioProfile_get_maxInstances(se::State& s)
+{
+    cocos2d::AudioProfile* cobj = (cocos2d::AudioProfile*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_audioengine_AudioProfile_get_maxInstances : Invalid Native Object");
+
+    CC_UNUSED bool ok = true;
+    se::Value jsret;
+    ok &= uint32_to_seval(cobj->maxInstances, &jsret);
+    s.rval() = jsret;
+    return true;
+}
+SE_BIND_PROP_GET(js_audioengine_AudioProfile_get_maxInstances)
+
+static bool js_audioengine_AudioProfile_set_maxInstances(se::State& s)
+{
+    const auto& args = s.args();
+    cocos2d::AudioProfile* cobj = (cocos2d::AudioProfile*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_audioengine_AudioProfile_set_maxInstances : Invalid Native Object");
+
+    CC_UNUSED bool ok = true;
+    unsigned int arg0 = 0;
+    ok &= seval_to_uint32(args[0], (uint32_t*)&arg0);
+    SE_PRECONDITION2(ok, false, "js_audioengine_AudioProfile_set_maxInstances : Error processing new value");
+    cobj->maxInstances = arg0;
+    return true;
+}
+SE_BIND_PROP_SET(js_audioengine_AudioProfile_set_maxInstances)
+
+static bool js_audioengine_AudioProfile_get_minDelay(se::State& s)
+{
+    cocos2d::AudioProfile* cobj = (cocos2d::AudioProfile*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_audioengine_AudioProfile_get_minDelay : Invalid Native Object");
+
+    CC_UNUSED bool ok = true;
+    se::Value jsret;
+    ok &= double_to_seval(cobj->minDelay, &jsret);
+    s.rval() = jsret;
+    return true;
+}
+SE_BIND_PROP_GET(js_audioengine_AudioProfile_get_minDelay)
+
+static bool js_audioengine_AudioProfile_set_minDelay(se::State& s)
+{
+    const auto& args = s.args();
+    cocos2d::AudioProfile* cobj = (cocos2d::AudioProfile*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_audioengine_AudioProfile_set_minDelay : Invalid Native Object");
+
+    CC_UNUSED bool ok = true;
+    double arg0 = 0;
+    ok &= seval_to_double(args[0], &arg0);
+    SE_PRECONDITION2(ok, false, "js_audioengine_AudioProfile_set_minDelay : Error processing new value");
+    cobj->minDelay = arg0;
+    return true;
+}
+SE_BIND_PROP_SET(js_audioengine_AudioProfile_set_minDelay)
+
+SE_DECLARE_FINALIZE_FUNC(js_cocos2d_AudioProfile_finalize)
+
+static bool js_audioengine_AudioProfile_constructor(se::State& s)
+{
+    cocos2d::AudioProfile* cobj = new (std::nothrow) cocos2d::AudioProfile();
+    s.thisObject()->setPrivateData(cobj);
+    se::NonRefNativePtrCreatedByCtorMap::emplace(cobj);
+    return true;
+}
+SE_BIND_CTOR(js_audioengine_AudioProfile_constructor, __jsb_cocos2d_AudioProfile_class, js_cocos2d_AudioProfile_finalize)
+
+
+
+
+static bool js_cocos2d_AudioProfile_finalize(se::State& s)
+{
+    CCLOGINFO("jsbindings: finalizing JS object %p (cocos2d::AudioProfile)", s.nativeThisObject());
+    auto iter = se::NonRefNativePtrCreatedByCtorMap::find(s.nativeThisObject());
+    if (iter != se::NonRefNativePtrCreatedByCtorMap::end())
+    {
+        se::NonRefNativePtrCreatedByCtorMap::erase(iter);
+        cocos2d::AudioProfile* cobj = (cocos2d::AudioProfile*)s.nativeThisObject();
+        delete cobj;
+    }
+    return true;
+}
+SE_BIND_FINALIZE_FUNC(js_cocos2d_AudioProfile_finalize)
+
+bool js_register_audioengine_AudioProfile(se::Object* obj)
+{
+    auto cls = se::Class::create("AudioProfile", obj, nullptr, _SE(js_audioengine_AudioProfile_constructor));
+
+    cls->defineProperty("name", _SE(js_audioengine_AudioProfile_get_name), _SE(js_audioengine_AudioProfile_set_name));
+    cls->defineProperty("maxInstances", _SE(js_audioengine_AudioProfile_get_maxInstances), _SE(js_audioengine_AudioProfile_set_maxInstances));
+    cls->defineProperty("minDelay", _SE(js_audioengine_AudioProfile_get_minDelay), _SE(js_audioengine_AudioProfile_set_minDelay));
+    cls->defineFinalizeFunction(_SE(js_cocos2d_AudioProfile_finalize));
+    cls->install();
+    JSBClassType::registerClass<cocos2d::AudioProfile>(cls);
+
+    __jsb_cocos2d_AudioProfile_proto = cls->getProto();
+    __jsb_cocos2d_AudioProfile_class = cls;
+
+    se::ScriptEngine::getInstance()->clearException();
+    return true;
+}
+
+se::Object* __jsb_cocos2d_AudioEngine_proto = nullptr;
+se::Class* __jsb_cocos2d_AudioEngine_class = nullptr;
+
+static bool js_audioengine_AudioEngine_lazyInit(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 0) {
+        bool result = cocos2d::AudioEngine::lazyInit();
+        ok &= boolean_to_seval(result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_lazyInit : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_audioengine_AudioEngine_lazyInit)
+
+static bool js_audioengine_AudioEngine_setCurrentTime(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 2) {
+        int arg0 = 0;
+        float arg1 = 0;
+        do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (int)tmp; } while(false);
+        ok &= seval_to_float(args[1], &arg1);
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_setCurrentTime : Error processing arguments");
+        bool result = cocos2d::AudioEngine::setCurrentTime(arg0, arg1);
+        ok &= boolean_to_seval(result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_setCurrentTime : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
+    return false;
+}
+SE_BIND_FUNC(js_audioengine_AudioEngine_setCurrentTime)
+
+static bool js_audioengine_AudioEngine_getVolume(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        int arg0 = 0;
+        do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (int)tmp; } while(false);
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_getVolume : Error processing arguments");
+        float result = cocos2d::AudioEngine::getVolume(arg0);
+        ok &= float_to_seval(result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_getVolume : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_audioengine_AudioEngine_getVolume)
+
+static bool js_audioengine_AudioEngine_uncache(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        std::string arg0;
+        ok &= seval_to_std_string(args[0], &arg0);
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_uncache : Error processing arguments");
+        cocos2d::AudioEngine::uncache(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_audioengine_AudioEngine_uncache)
+
+static bool js_audioengine_AudioEngine_resumeAll(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    if (argc == 0) {
+        cocos2d::AudioEngine::resumeAll();
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_audioengine_AudioEngine_resumeAll)
+
+static bool js_audioengine_AudioEngine_stopAll(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    if (argc == 0) {
+        cocos2d::AudioEngine::stopAll();
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_audioengine_AudioEngine_stopAll)
+
+static bool js_audioengine_AudioEngine_pause(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        int arg0 = 0;
+        do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (int)tmp; } while(false);
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_pause : Error processing arguments");
+        cocos2d::AudioEngine::pause(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_audioengine_AudioEngine_pause)
+
+static bool js_audioengine_AudioEngine_end(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    if (argc == 0) {
+        cocos2d::AudioEngine::end();
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_audioengine_AudioEngine_end)
+
+static bool js_audioengine_AudioEngine_getMaxAudioInstance(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 0) {
+        int result = cocos2d::AudioEngine::getMaxAudioInstance();
+        ok &= int32_to_seval(result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_getMaxAudioInstance : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_audioengine_AudioEngine_getMaxAudioInstance)
+
+static bool js_audioengine_AudioEngine_isEnabled(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 0) {
+        bool result = cocos2d::AudioEngine::isEnabled();
+        ok &= boolean_to_seval(result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_isEnabled : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_audioengine_AudioEngine_isEnabled)
+
+static bool js_audioengine_AudioEngine_getDurationFromFile(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        std::string arg0;
+        ok &= seval_to_std_string(args[0], &arg0);
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_getDurationFromFile : Error processing arguments");
+        float result = cocos2d::AudioEngine::getDurationFromFile(arg0);
+        ok &= float_to_seval(result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_getDurationFromFile : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_audioengine_AudioEngine_getDurationFromFile)
+
+static bool js_audioengine_AudioEngine_getCurrentTime(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        int arg0 = 0;
+        do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (int)tmp; } while(false);
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_getCurrentTime : Error processing arguments");
+        float result = cocos2d::AudioEngine::getCurrentTime(arg0);
+        ok &= float_to_seval(result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_getCurrentTime : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_audioengine_AudioEngine_getCurrentTime)
+
+static bool js_audioengine_AudioEngine_setMaxAudioInstance(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        int arg0 = 0;
+        do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (int)tmp; } while(false);
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_setMaxAudioInstance : Error processing arguments");
+        bool result = cocos2d::AudioEngine::setMaxAudioInstance(arg0);
+        ok &= boolean_to_seval(result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_setMaxAudioInstance : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_audioengine_AudioEngine_setMaxAudioInstance)
+
+static bool js_audioengine_AudioEngine_isLoop(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        int arg0 = 0;
+        do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (int)tmp; } while(false);
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_isLoop : Error processing arguments");
+        bool result = cocos2d::AudioEngine::isLoop(arg0);
+        ok &= boolean_to_seval(result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_isLoop : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_audioengine_AudioEngine_isLoop)
+
+static bool js_audioengine_AudioEngine_pauseAll(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    if (argc == 0) {
+        cocos2d::AudioEngine::pauseAll();
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_audioengine_AudioEngine_pauseAll)
+
+static bool js_audioengine_AudioEngine_uncacheAll(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    if (argc == 0) {
+        cocos2d::AudioEngine::uncacheAll();
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_audioengine_AudioEngine_uncacheAll)
+
+static bool js_audioengine_AudioEngine_setVolume(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 2) {
+        int arg0 = 0;
+        float arg1 = 0;
+        do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (int)tmp; } while(false);
+        ok &= seval_to_float(args[1], &arg1);
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_setVolume : Error processing arguments");
+        cocos2d::AudioEngine::setVolume(arg0, arg1);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
+    return false;
+}
+SE_BIND_FUNC(js_audioengine_AudioEngine_setVolume)
+
+static bool js_audioengine_AudioEngine_preload(se::State& s)
+{
+    CC_UNUSED bool ok = true;
+    const auto& args = s.args();
+    size_t argc = args.size();
+    do {
+        if (argc == 2) {
+            std::string arg0;
+            ok &= seval_to_std_string(args[0], &arg0);
+            if (!ok) { ok = true; break; }
+            std::function<void (bool)> arg1;
+            do {
+                if (args[1].isObject() && args[1].toObject()->isFunction())
+                {
+                    se::Value jsThis(s.thisObject());
+                    se::Value jsFunc(args[1]);
+                    jsFunc.toObject()->root();
+                    auto lambda = [=](bool larg0) -> void {
+                        se::ScriptEngine::getInstance()->clearException();
+                        se::AutoHandleScope hs;
+            
+                        CC_UNUSED bool ok = true;
+                        se::ValueArray args;
+                        args.resize(1);
+                        ok &= boolean_to_seval(larg0, &args[0]);
+                        se::Value rval;
+                        se::Object* thisObj = jsThis.isObject() ? jsThis.toObject() : nullptr;
+                        se::Object* funcObj = jsFunc.toObject();
+                        bool succeed = funcObj->call(args, thisObj, &rval);
+                        if (!succeed) {
+                            se::ScriptEngine::getInstance()->clearException();
+                        }
+                    };
+                    arg1 = lambda;
+                }
+                else
+                {
+                    arg1 = nullptr;
+                }
+            } while(false)
+            ;
+            if (!ok) { ok = true; break; }
+            cocos2d::AudioEngine::preload(arg0, arg1);
+            return true;
+        }
+    } while (false);
+    do {
+        if (argc == 1) {
+            std::string arg0;
+            ok &= seval_to_std_string(args[0], &arg0);
+            if (!ok) { ok = true; break; }
+            cocos2d::AudioEngine::preload(arg0);
+            return true;
+        }
+    } while (false);
+    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
+    return false;
+}
+SE_BIND_FUNC(js_audioengine_AudioEngine_preload)
+
+static bool js_audioengine_AudioEngine_setEnabled(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        bool arg0;
+        ok &= seval_to_boolean(args[0], &arg0);
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_setEnabled : Error processing arguments");
+        cocos2d::AudioEngine::setEnabled(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_audioengine_AudioEngine_setEnabled)
+
+static bool js_audioengine_AudioEngine_play2d(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        std::string arg0;
+        ok &= seval_to_std_string(args[0], &arg0);
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_play2d : Error processing arguments");
+        int result = cocos2d::AudioEngine::play2d(arg0);
+        ok &= int32_to_seval(result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_play2d : Error processing arguments");
+        return true;
+    }
+    if (argc == 2) {
+        std::string arg0;
+        bool arg1;
+        ok &= seval_to_std_string(args[0], &arg0);
+        ok &= seval_to_boolean(args[1], &arg1);
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_play2d : Error processing arguments");
+        int result = cocos2d::AudioEngine::play2d(arg0, arg1);
+        ok &= int32_to_seval(result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_play2d : Error processing arguments");
+        return true;
+    }
+    if (argc == 3) {
+        std::string arg0;
+        bool arg1;
+        float arg2 = 0;
+        ok &= seval_to_std_string(args[0], &arg0);
+        ok &= seval_to_boolean(args[1], &arg1);
+        ok &= seval_to_float(args[2], &arg2);
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_play2d : Error processing arguments");
+        int result = cocos2d::AudioEngine::play2d(arg0, arg1, arg2);
+        ok &= int32_to_seval(result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_play2d : Error processing arguments");
+        return true;
+    }
+    if (argc == 4) {
+        std::string arg0;
+        bool arg1;
+        float arg2 = 0;
+        const cocos2d::AudioProfile* arg3 = nullptr;
+        ok &= seval_to_std_string(args[0], &arg0);
+        ok &= seval_to_boolean(args[1], &arg1);
+        ok &= seval_to_float(args[2], &arg2);
+        ok &= seval_to_native_ptr(args[3], &arg3);
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_play2d : Error processing arguments");
+        int result = cocos2d::AudioEngine::play2d(arg0, arg1, arg2, arg3);
+        ok &= int32_to_seval(result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_play2d : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4);
+    return false;
+}
+SE_BIND_FUNC(js_audioengine_AudioEngine_play2d)
+
+static bool js_audioengine_AudioEngine_getState(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        int arg0 = 0;
+        do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (int)tmp; } while(false);
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_getState : Error processing arguments");
+        int result = (int)cocos2d::AudioEngine::getState(arg0);
+        ok &= int32_to_seval(result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_getState : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_audioengine_AudioEngine_getState)
+
+static bool js_audioengine_AudioEngine_resume(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        int arg0 = 0;
+        do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (int)tmp; } while(false);
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_resume : Error processing arguments");
+        cocos2d::AudioEngine::resume(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_audioengine_AudioEngine_resume)
+
+static bool js_audioengine_AudioEngine_stop(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        int arg0 = 0;
+        do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (int)tmp; } while(false);
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_stop : Error processing arguments");
+        cocos2d::AudioEngine::stop(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_audioengine_AudioEngine_stop)
+
+static bool js_audioengine_AudioEngine_getDuration(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        int arg0 = 0;
+        do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (int)tmp; } while(false);
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_getDuration : Error processing arguments");
+        float result = cocos2d::AudioEngine::getDuration(arg0);
+        ok &= float_to_seval(result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_getDuration : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_audioengine_AudioEngine_getDuration)
+
+static bool js_audioengine_AudioEngine_setLoop(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 2) {
+        int arg0 = 0;
+        bool arg1;
+        do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (int)tmp; } while(false);
+        ok &= seval_to_boolean(args[1], &arg1);
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_setLoop : Error processing arguments");
+        cocos2d::AudioEngine::setLoop(arg0, arg1);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
+    return false;
+}
+SE_BIND_FUNC(js_audioengine_AudioEngine_setLoop)
+
+static bool js_audioengine_AudioEngine_getDefaultProfile(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 0) {
+        cocos2d::AudioProfile* result = cocos2d::AudioEngine::getDefaultProfile();
+        ok &= native_ptr_to_seval<cocos2d::AudioProfile>((cocos2d::AudioProfile*)result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_getDefaultProfile : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_audioengine_AudioEngine_getDefaultProfile)
+
+static bool js_audioengine_AudioEngine_setFinishCallback(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 2) {
+        int arg0 = 0;
+        std::function<void (int, const std::string&)> arg1;
+        do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (int)tmp; } while(false);
+        do {
+            if (args[1].isObject() && args[1].toObject()->isFunction())
+            {
+                se::Value jsThis(s.thisObject());
+                se::Value jsFunc(args[1]);
+                jsFunc.toObject()->root();
+                auto lambda = [=](int larg0, const std::string& larg1) -> void {
+                    se::ScriptEngine::getInstance()->clearException();
+                    se::AutoHandleScope hs;
+        
+                    CC_UNUSED bool ok = true;
+                    se::ValueArray args;
+                    args.resize(2);
+                    ok &= int32_to_seval(larg0, &args[0]);
+                    ok &= std_string_to_seval(larg1, &args[1]);
+                    se::Value rval;
+                    se::Object* thisObj = jsThis.isObject() ? jsThis.toObject() : nullptr;
+                    se::Object* funcObj = jsFunc.toObject();
+                    bool succeed = funcObj->call(args, thisObj, &rval);
+                    if (!succeed) {
+                        se::ScriptEngine::getInstance()->clearException();
+                    }
+                };
+                arg1 = lambda;
+            }
+            else
+            {
+                arg1 = nullptr;
+            }
+        } while(false)
+        ;
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_setFinishCallback : Error processing arguments");
+        cocos2d::AudioEngine::setFinishCallback(arg0, arg1);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
+    return false;
+}
+SE_BIND_FUNC(js_audioengine_AudioEngine_setFinishCallback)
+
+static bool js_audioengine_AudioEngine_getProfile(se::State& s)
+{
+    CC_UNUSED bool ok = true;
+    const auto& args = s.args();
+    size_t argc = args.size();
+    do {
+        if (argc == 1) {
+            std::string arg0;
+            ok &= seval_to_std_string(args[0], &arg0);
+            if (!ok) { ok = true; break; }
+            cocos2d::AudioProfile* result = cocos2d::AudioEngine::getProfile(arg0);
+            ok &= native_ptr_to_seval<cocos2d::AudioProfile>((cocos2d::AudioProfile*)result, &s.rval());
+            SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_getProfile : Error processing arguments");
+            return true;
+        }
+    } while (false);
+    do {
+        if (argc == 1) {
+            int arg0 = 0;
+            do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (int)tmp; } while(false);
+            if (!ok) { ok = true; break; }
+            cocos2d::AudioProfile* result = cocos2d::AudioEngine::getProfile(arg0);
+            ok &= native_ptr_to_seval<cocos2d::AudioProfile>((cocos2d::AudioProfile*)result, &s.rval());
+            SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_getProfile : Error processing arguments");
+            return true;
+        }
+    } while (false);
+    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
+    return false;
+}
+SE_BIND_FUNC(js_audioengine_AudioEngine_getProfile)
+
+static bool js_audioengine_AudioEngine_getPlayingAudioCount(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 0) {
+        int result = cocos2d::AudioEngine::getPlayingAudioCount();
+        ok &= int32_to_seval(result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_audioengine_AudioEngine_getPlayingAudioCount : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_audioengine_AudioEngine_getPlayingAudioCount)
+
+
+
+
+bool js_register_audioengine_AudioEngine(se::Object* obj)
+{
+    auto cls = se::Class::create("AudioEngine", obj, nullptr, nullptr);
+
+    cls->defineStaticFunction("lazyInit", _SE(js_audioengine_AudioEngine_lazyInit));
+    cls->defineStaticFunction("setCurrentTime", _SE(js_audioengine_AudioEngine_setCurrentTime));
+    cls->defineStaticFunction("getVolume", _SE(js_audioengine_AudioEngine_getVolume));
+    cls->defineStaticFunction("uncache", _SE(js_audioengine_AudioEngine_uncache));
+    cls->defineStaticFunction("resumeAll", _SE(js_audioengine_AudioEngine_resumeAll));
+    cls->defineStaticFunction("stopAll", _SE(js_audioengine_AudioEngine_stopAll));
+    cls->defineStaticFunction("pause", _SE(js_audioengine_AudioEngine_pause));
+    cls->defineStaticFunction("end", _SE(js_audioengine_AudioEngine_end));
+    cls->defineStaticFunction("getMaxAudioInstance", _SE(js_audioengine_AudioEngine_getMaxAudioInstance));
+    cls->defineStaticFunction("isEnabled", _SE(js_audioengine_AudioEngine_isEnabled));
+    cls->defineStaticFunction("getDurationFromFile", _SE(js_audioengine_AudioEngine_getDurationFromFile));
+    cls->defineStaticFunction("getCurrentTime", _SE(js_audioengine_AudioEngine_getCurrentTime));
+    cls->defineStaticFunction("setMaxAudioInstance", _SE(js_audioengine_AudioEngine_setMaxAudioInstance));
+    cls->defineStaticFunction("isLoop", _SE(js_audioengine_AudioEngine_isLoop));
+    cls->defineStaticFunction("pauseAll", _SE(js_audioengine_AudioEngine_pauseAll));
+    cls->defineStaticFunction("uncacheAll", _SE(js_audioengine_AudioEngine_uncacheAll));
+    cls->defineStaticFunction("setVolume", _SE(js_audioengine_AudioEngine_setVolume));
+    cls->defineStaticFunction("preload", _SE(js_audioengine_AudioEngine_preload));
+    cls->defineStaticFunction("setEnabled", _SE(js_audioengine_AudioEngine_setEnabled));
+    cls->defineStaticFunction("play2d", _SE(js_audioengine_AudioEngine_play2d));
+    cls->defineStaticFunction("getState", _SE(js_audioengine_AudioEngine_getState));
+    cls->defineStaticFunction("resume", _SE(js_audioengine_AudioEngine_resume));
+    cls->defineStaticFunction("stop", _SE(js_audioengine_AudioEngine_stop));
+    cls->defineStaticFunction("getDuration", _SE(js_audioengine_AudioEngine_getDuration));
+    cls->defineStaticFunction("setLoop", _SE(js_audioengine_AudioEngine_setLoop));
+    cls->defineStaticFunction("getDefaultProfile", _SE(js_audioengine_AudioEngine_getDefaultProfile));
+    cls->defineStaticFunction("setFinishCallback", _SE(js_audioengine_AudioEngine_setFinishCallback));
+    cls->defineStaticFunction("getProfile", _SE(js_audioengine_AudioEngine_getProfile));
+    cls->defineStaticFunction("getPlayingAudioCount", _SE(js_audioengine_AudioEngine_getPlayingAudioCount));
+    cls->install();
+    JSBClassType::registerClass<cocos2d::AudioEngine>(cls);
+
+    __jsb_cocos2d_AudioEngine_proto = cls->getProto();
+    __jsb_cocos2d_AudioEngine_class = cls;
+
+    se::ScriptEngine::getInstance()->clearException();
+    return true;
+}
+
+bool register_all_audioengine(se::Object* obj)
+{
+    // Get the ns
+    se::Value nsVal;
+    if (!obj->getProperty("jsb", &nsVal))
+    {
+        se::HandleObject jsobj(se::Object::createPlainObject());
+        nsVal.setObject(jsobj);
+        obj->setProperty("jsb", nsVal);
+    }
+    se::Object* ns = nsVal.toObject();
+
+    js_register_audioengine_AudioProfile(ns);
+    js_register_audioengine_AudioEngine(ns);
+    return true;
+}
+
+#endif //#if (USE_AUDIO > 0) && (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID || CC_TARGET_PLATFORM == CC_PLATFORM_IOS || CC_TARGET_PLATFORM == CC_PLATFORM_MAC || CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)

cocos2d-x/cocos/scripting/js-bindings/auto/jsb_cocos2dx_audioengine_auto.hpp

@@ -0,0 +1,49 @@
+#pragma once
+#include "base/ccConfig.h"
+#if (USE_AUDIO > 0) && (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID || CC_TARGET_PLATFORM == CC_PLATFORM_IOS || CC_TARGET_PLATFORM == CC_PLATFORM_MAC || CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)
+
+#include "cocos/scripting/js-bindings/jswrapper/SeApi.h"
+
+extern se::Object* __jsb_cocos2d_AudioProfile_proto;
+extern se::Class* __jsb_cocos2d_AudioProfile_class;
+
+bool js_register_cocos2d_AudioProfile(se::Object* obj);
+bool register_all_audioengine(se::Object* obj);
+SE_DECLARE_FUNC(js_audioengine_AudioProfile_AudioProfile);
+
+extern se::Object* __jsb_cocos2d_AudioEngine_proto;
+extern se::Class* __jsb_cocos2d_AudioEngine_class;
+
+bool js_register_cocos2d_AudioEngine(se::Object* obj);
+bool register_all_audioengine(se::Object* obj);
+SE_DECLARE_FUNC(js_audioengine_AudioEngine_lazyInit);
+SE_DECLARE_FUNC(js_audioengine_AudioEngine_setCurrentTime);
+SE_DECLARE_FUNC(js_audioengine_AudioEngine_getVolume);
+SE_DECLARE_FUNC(js_audioengine_AudioEngine_uncache);
+SE_DECLARE_FUNC(js_audioengine_AudioEngine_resumeAll);
+SE_DECLARE_FUNC(js_audioengine_AudioEngine_stopAll);
+SE_DECLARE_FUNC(js_audioengine_AudioEngine_pause);
+SE_DECLARE_FUNC(js_audioengine_AudioEngine_end);
+SE_DECLARE_FUNC(js_audioengine_AudioEngine_getMaxAudioInstance);
+SE_DECLARE_FUNC(js_audioengine_AudioEngine_isEnabled);
+SE_DECLARE_FUNC(js_audioengine_AudioEngine_getDurationFromFile);
+SE_DECLARE_FUNC(js_audioengine_AudioEngine_getCurrentTime);
+SE_DECLARE_FUNC(js_audioengine_AudioEngine_setMaxAudioInstance);
+SE_DECLARE_FUNC(js_audioengine_AudioEngine_isLoop);
+SE_DECLARE_FUNC(js_audioengine_AudioEngine_pauseAll);
+SE_DECLARE_FUNC(js_audioengine_AudioEngine_uncacheAll);
+SE_DECLARE_FUNC(js_audioengine_AudioEngine_setVolume);
+SE_DECLARE_FUNC(js_audioengine_AudioEngine_preload);
+SE_DECLARE_FUNC(js_audioengine_AudioEngine_setEnabled);
+SE_DECLARE_FUNC(js_audioengine_AudioEngine_play2d);
+SE_DECLARE_FUNC(js_audioengine_AudioEngine_getState);
+SE_DECLARE_FUNC(js_audioengine_AudioEngine_resume);
+SE_DECLARE_FUNC(js_audioengine_AudioEngine_stop);
+SE_DECLARE_FUNC(js_audioengine_AudioEngine_getDuration);
+SE_DECLARE_FUNC(js_audioengine_AudioEngine_setLoop);
+SE_DECLARE_FUNC(js_audioengine_AudioEngine_getDefaultProfile);
+SE_DECLARE_FUNC(js_audioengine_AudioEngine_setFinishCallback);
+SE_DECLARE_FUNC(js_audioengine_AudioEngine_getProfile);
+SE_DECLARE_FUNC(js_audioengine_AudioEngine_getPlayingAudioCount);
+
+#endif //#if (USE_AUDIO > 0) && (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID || CC_TARGET_PLATFORM == CC_PLATFORM_IOS || CC_TARGET_PLATFORM == CC_PLATFORM_MAC || CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)

cocos2d-x/cocos/scripting/js-bindings/auto/jsb_cocos2dx_auto.hpp

@@ -0,0 +1,126 @@
+#pragma once
+#include "base/ccConfig.h"
+
+#include "cocos/scripting/js-bindings/jswrapper/SeApi.h"
+
+extern se::Object* __jsb_cocos2d_FileUtils_proto;
+extern se::Class* __jsb_cocos2d_FileUtils_class;
+
+bool js_register_cocos2d_FileUtils(se::Object* obj);
+bool register_all_engine(se::Object* obj);
+SE_DECLARE_FUNC(js_engine_FileUtils_writeDataToFile);
+SE_DECLARE_FUNC(js_engine_FileUtils_fullPathForFilename);
+SE_DECLARE_FUNC(js_engine_FileUtils_getStringFromFile);
+SE_DECLARE_FUNC(js_engine_FileUtils_removeFile);
+SE_DECLARE_FUNC(js_engine_FileUtils_getDataFromFile);
+SE_DECLARE_FUNC(js_engine_FileUtils_isAbsolutePath);
+SE_DECLARE_FUNC(js_engine_FileUtils_renameFile);
+SE_DECLARE_FUNC(js_engine_FileUtils_normalizePath);
+SE_DECLARE_FUNC(js_engine_FileUtils_getDefaultResourceRootPath);
+SE_DECLARE_FUNC(js_engine_FileUtils_loadFilenameLookupDictionaryFromFile);
+SE_DECLARE_FUNC(js_engine_FileUtils_isPopupNotify);
+SE_DECLARE_FUNC(js_engine_FileUtils_getValueVectorFromFile);
+SE_DECLARE_FUNC(js_engine_FileUtils_getSearchPaths);
+SE_DECLARE_FUNC(js_engine_FileUtils_getFileDir);
+SE_DECLARE_FUNC(js_engine_FileUtils_writeToFile);
+SE_DECLARE_FUNC(js_engine_FileUtils_getOriginalSearchPaths);
+SE_DECLARE_FUNC(js_engine_FileUtils_listFiles);
+SE_DECLARE_FUNC(js_engine_FileUtils_getValueMapFromFile);
+SE_DECLARE_FUNC(js_engine_FileUtils_getFileSize);
+SE_DECLARE_FUNC(js_engine_FileUtils_getValueMapFromData);
+SE_DECLARE_FUNC(js_engine_FileUtils_removeDirectory);
+SE_DECLARE_FUNC(js_engine_FileUtils_setSearchPaths);
+SE_DECLARE_FUNC(js_engine_FileUtils_writeStringToFile);
+SE_DECLARE_FUNC(js_engine_FileUtils_setSearchResolutionsOrder);
+SE_DECLARE_FUNC(js_engine_FileUtils_addSearchResolutionsOrder);
+SE_DECLARE_FUNC(js_engine_FileUtils_addSearchPath);
+SE_DECLARE_FUNC(js_engine_FileUtils_writeValueVectorToFile);
+SE_DECLARE_FUNC(js_engine_FileUtils_isFileExist);
+SE_DECLARE_FUNC(js_engine_FileUtils_purgeCachedEntries);
+SE_DECLARE_FUNC(js_engine_FileUtils_fullPathFromRelativeFile);
+SE_DECLARE_FUNC(js_engine_FileUtils_getSuitableFOpen);
+SE_DECLARE_FUNC(js_engine_FileUtils_writeValueMapToFile);
+SE_DECLARE_FUNC(js_engine_FileUtils_getFileExtension);
+SE_DECLARE_FUNC(js_engine_FileUtils_setWritablePath);
+SE_DECLARE_FUNC(js_engine_FileUtils_setPopupNotify);
+SE_DECLARE_FUNC(js_engine_FileUtils_isDirectoryExist);
+SE_DECLARE_FUNC(js_engine_FileUtils_setDefaultResourceRootPath);
+SE_DECLARE_FUNC(js_engine_FileUtils_getSearchResolutionsOrder);
+SE_DECLARE_FUNC(js_engine_FileUtils_createDirectory);
+SE_DECLARE_FUNC(js_engine_FileUtils_getWritablePath);
+SE_DECLARE_FUNC(js_engine_FileUtils_setDelegate);
+SE_DECLARE_FUNC(js_engine_FileUtils_getInstance);
+
+extern se::Object* __jsb_cocos2d_Device_proto;
+extern se::Class* __jsb_cocos2d_Device_class;
+
+bool js_register_cocos2d_Device(se::Object* obj);
+bool register_all_engine(se::Object* obj);
+SE_DECLARE_FUNC(js_engine_Device_getDevicePixelRatio);
+SE_DECLARE_FUNC(js_engine_Device_setAccelerometerEnabled);
+SE_DECLARE_FUNC(js_engine_Device_setAccelerometerInterval);
+SE_DECLARE_FUNC(js_engine_Device_vibrate);
+SE_DECLARE_FUNC(js_engine_Device_setKeepScreenOn);
+SE_DECLARE_FUNC(js_engine_Device_getNetworkType);
+SE_DECLARE_FUNC(js_engine_Device_getBatteryLevel);
+SE_DECLARE_FUNC(js_engine_Device_getDeviceRotation);
+SE_DECLARE_FUNC(js_engine_Device_getDPI);
+SE_DECLARE_FUNC(js_engine_Device_getSafeAreaEdge);
+SE_DECLARE_FUNC(js_engine_Device_getDeviceModel);
+
+extern se::Object* __jsb_cocos2d_SAXParser_proto;
+extern se::Class* __jsb_cocos2d_SAXParser_class;
+
+bool js_register_cocos2d_SAXParser(se::Object* obj);
+bool register_all_engine(se::Object* obj);
+SE_DECLARE_FUNC(js_engine_SAXParser_init);
+
+extern se::Object* __jsb_cocos2d_CanvasGradient_proto;
+extern se::Class* __jsb_cocos2d_CanvasGradient_class;
+
+bool js_register_cocos2d_CanvasGradient(se::Object* obj);
+bool register_all_engine(se::Object* obj);
+SE_DECLARE_FUNC(js_engine_CanvasGradient_addColorStop);
+SE_DECLARE_FUNC(js_engine_CanvasGradient_CanvasGradient);
+
+extern se::Object* __jsb_cocos2d_CanvasRenderingContext2D_proto;
+extern se::Class* __jsb_cocos2d_CanvasRenderingContext2D_class;
+
+bool js_register_cocos2d_CanvasRenderingContext2D(se::Object* obj);
+bool register_all_engine(se::Object* obj);
+SE_DECLARE_FUNC(js_engine_CanvasRenderingContext2D_restore);
+SE_DECLARE_FUNC(js_engine_CanvasRenderingContext2D_moveTo);
+SE_DECLARE_FUNC(js_engine_CanvasRenderingContext2D_lineTo);
+SE_DECLARE_FUNC(js_engine_CanvasRenderingContext2D_setPremultiply);
+SE_DECLARE_FUNC(js_engine_CanvasRenderingContext2D_setTransform);
+SE_DECLARE_FUNC(js_engine_CanvasRenderingContext2D_stroke);
+SE_DECLARE_FUNC(js_engine_CanvasRenderingContext2D_measureText);
+SE_DECLARE_FUNC(js_engine_CanvasRenderingContext2D_fill);
+SE_DECLARE_FUNC(js_engine_CanvasRenderingContext2D__fillImageData);
+SE_DECLARE_FUNC(js_engine_CanvasRenderingContext2D_scale);
+SE_DECLARE_FUNC(js_engine_CanvasRenderingContext2D_clearRect);
+SE_DECLARE_FUNC(js_engine_CanvasRenderingContext2D_transform);
+SE_DECLARE_FUNC(js_engine_CanvasRenderingContext2D_fillText);
+SE_DECLARE_FUNC(js_engine_CanvasRenderingContext2D_strokeText);
+SE_DECLARE_FUNC(js_engine_CanvasRenderingContext2D_save);
+SE_DECLARE_FUNC(js_engine_CanvasRenderingContext2D_fillRect);
+SE_DECLARE_FUNC(js_engine_CanvasRenderingContext2D_rotate);
+SE_DECLARE_FUNC(js_engine_CanvasRenderingContext2D_beginPath);
+SE_DECLARE_FUNC(js_engine_CanvasRenderingContext2D_rect);
+SE_DECLARE_FUNC(js_engine_CanvasRenderingContext2D_translate);
+SE_DECLARE_FUNC(js_engine_CanvasRenderingContext2D_createLinearGradient);
+SE_DECLARE_FUNC(js_engine_CanvasRenderingContext2D_closePath);
+SE_DECLARE_FUNC(js_engine_CanvasRenderingContext2D_CanvasRenderingContext2D);
+
+extern se::Object* __jsb_cocos2d_LabelRenderer_proto;
+extern se::Class* __jsb_cocos2d_LabelRenderer_class;
+
+bool js_register_cocos2d_LabelRenderer(se::Object* obj);
+bool register_all_engine(se::Object* obj);
+SE_DECLARE_FUNC(js_engine_LabelRenderer_setEffect);
+SE_DECLARE_FUNC(js_engine_LabelRenderer_bindNodeProxy);
+SE_DECLARE_FUNC(js_engine_LabelRenderer_render);
+SE_DECLARE_FUNC(js_engine_LabelRenderer_setJsComponent);
+SE_DECLARE_FUNC(js_engine_LabelRenderer_getJsComponent);
+SE_DECLARE_FUNC(js_engine_LabelRenderer_LabelRenderer);
+

cocos2d-x/cocos/scripting/js-bindings/auto/jsb_cocos2dx_dragonbones_auto.hpp

@@ -0,0 +1,516 @@
+#pragma once
+#include "base/ccConfig.h"
+#if USE_DRAGONBONES > 0
+
+#include "cocos/scripting/js-bindings/jswrapper/SeApi.h"
+
+extern se::Object* __jsb_dragonBones_BaseObject_proto;
+extern se::Class* __jsb_dragonBones_BaseObject_class;
+
+bool js_register_dragonBones_BaseObject(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_BaseObject_returnToPool);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_BaseObject_clearPool);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_BaseObject_setMaxCount);
+
+extern se::Object* __jsb_dragonBones_Matrix_proto;
+extern se::Class* __jsb_dragonBones_Matrix_class;
+
+bool js_register_dragonBones_Matrix(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+
+extern se::Object* __jsb_dragonBones_Transform_proto;
+extern se::Class* __jsb_dragonBones_Transform_class;
+
+bool js_register_dragonBones_Transform(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Transform_normalizeRadian);
+
+extern se::Object* __jsb_dragonBones_TextureAtlasData_proto;
+extern se::Class* __jsb_dragonBones_TextureAtlasData_class;
+
+bool js_register_dragonBones_TextureAtlasData(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_TextureAtlasData_createTexture);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_TextureAtlasData_getTexture);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_TextureAtlasData_addTexture);
+
+extern se::Object* __jsb_dragonBones_TextureData_proto;
+extern se::Class* __jsb_dragonBones_TextureData_class;
+
+bool js_register_dragonBones_TextureData(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_TextureData_getParent);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_TextureData_setFrame);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_TextureData_getRegion);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_TextureData_getFrame);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_TextureData_setParent);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_TextureData_createRectangle);
+
+extern se::Object* __jsb_dragonBones_UserData_proto;
+extern se::Class* __jsb_dragonBones_UserData_class;
+
+bool js_register_dragonBones_UserData(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_UserData_getFloat);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_UserData_getFloats);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_UserData_getString);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_UserData_getInts);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_UserData_getInt);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_UserData_addInt);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_UserData_getStrings);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_UserData_addFloat);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_UserData_addString);
+
+extern se::Object* __jsb_dragonBones_ArmatureData_proto;
+extern se::Class* __jsb_dragonBones_ArmatureData_class;
+
+bool js_register_dragonBones_ArmatureData(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_ArmatureData_getBone);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_ArmatureData_addAction);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_ArmatureData_setUserData);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_ArmatureData_getSlot);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_ArmatureData_getSkin);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_ArmatureData_setDefaultAnimation);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_ArmatureData_setType);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_ArmatureData_setParent);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_ArmatureData_getDefaultSkin);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_ArmatureData_getMesh);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_ArmatureData_setDefaultSkin);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_ArmatureData_getAnimationNames);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_ArmatureData_getType);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_ArmatureData_addConstraint);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_ArmatureData_getUserData);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_ArmatureData_getAABB);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_ArmatureData_getParent);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_ArmatureData_getDefaultAnimation);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_ArmatureData_getAnimation);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_ArmatureData_getConstraint);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_ArmatureData_sortBones);
+
+extern se::Object* __jsb_dragonBones_BoneData_proto;
+extern se::Class* __jsb_dragonBones_BoneData_class;
+
+bool js_register_dragonBones_BoneData(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_BoneData_setParent);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_BoneData_getTransfrom);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_BoneData_setUserData);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_BoneData_getUserData);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_BoneData_getParent);
+
+extern se::Object* __jsb_dragonBones_SlotData_proto;
+extern se::Class* __jsb_dragonBones_SlotData_class;
+
+bool js_register_dragonBones_SlotData(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_SlotData_setUserData);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_SlotData_setColor);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_SlotData_getUserData);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_SlotData_getColor);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_SlotData_setBlendMode);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_SlotData_getBlendMode);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_SlotData_setParent);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_SlotData_getParent);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_SlotData_createColor);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_SlotData_getDefaultColor);
+
+extern se::Object* __jsb_dragonBones_DragonBonesData_proto;
+extern se::Class* __jsb_dragonBones_DragonBonesData_class;
+
+bool js_register_dragonBones_DragonBonesData(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_DragonBonesData_setUserData);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_DragonBonesData_getUserData);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_DragonBonesData_getFrameIndices);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_DragonBonesData_getArmature);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_DragonBonesData_getArmatureNames);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_DragonBonesData_addArmature);
+
+extern se::Object* __jsb_dragonBones_SkinData_proto;
+extern se::Class* __jsb_dragonBones_SkinData_class;
+
+bool js_register_dragonBones_SkinData(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_SkinData_addDisplay);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_SkinData_getDisplay);
+
+extern se::Object* __jsb_dragonBones_BoundingBoxData_proto;
+extern se::Class* __jsb_dragonBones_BoundingBoxData_class;
+
+bool js_register_dragonBones_BoundingBoxData(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_BoundingBoxData_intersectsSegment);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_BoundingBoxData_containsPoint);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_BoundingBoxData_getType);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_BoundingBoxData_setType);
+
+extern se::Object* __jsb_dragonBones_RectangleBoundingBoxData_proto;
+extern se::Class* __jsb_dragonBones_RectangleBoundingBoxData_class;
+
+bool js_register_dragonBones_RectangleBoundingBoxData(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_RectangleBoundingBoxData_rectangleIntersectsSegment);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_RectangleBoundingBoxData_getTypeIndex);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_RectangleBoundingBoxData_RectangleBoundingBoxData);
+
+extern se::Object* __jsb_dragonBones_EllipseBoundingBoxData_proto;
+extern se::Class* __jsb_dragonBones_EllipseBoundingBoxData_class;
+
+bool js_register_dragonBones_EllipseBoundingBoxData(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_EllipseBoundingBoxData_getTypeIndex);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_EllipseBoundingBoxData_ellipseIntersectsSegment);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_EllipseBoundingBoxData_EllipseBoundingBoxData);
+
+extern se::Object* __jsb_dragonBones_PolygonBoundingBoxData_proto;
+extern se::Class* __jsb_dragonBones_PolygonBoundingBoxData_class;
+
+bool js_register_dragonBones_PolygonBoundingBoxData(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_PolygonBoundingBoxData_getVertices);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_PolygonBoundingBoxData_getTypeIndex);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_PolygonBoundingBoxData_polygonIntersectsSegment);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_PolygonBoundingBoxData_PolygonBoundingBoxData);
+
+extern se::Object* __jsb_dragonBones_AnimationData_proto;
+extern se::Class* __jsb_dragonBones_AnimationData_class;
+
+bool js_register_dragonBones_AnimationData(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_AnimationData_getActionTimeline);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_AnimationData_setParent);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_AnimationData_setActionTimeline);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_AnimationData_getSlotCachedFrameIndices);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_AnimationData_addConstraintTimeline);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_AnimationData_getBoneCachedFrameIndices);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_AnimationData_getZOrderTimeline);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_AnimationData_setZOrderTimeline);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_AnimationData_getParent);
+
+extern se::Object* __jsb_dragonBones_Armature_proto;
+extern se::Class* __jsb_dragonBones_Armature_class;
+
+bool js_register_dragonBones_Armature(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Armature_getBone);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Armature_getClock);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Armature_render);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Armature_getSlot);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Armature_setClock);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Armature__bufferAction);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Armature__addBone);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Armature_getAnimatable);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Armature_getName);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Armature_dispose);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Armature_invalidUpdate);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Armature_getCacheFrameRate);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Armature_getFlipY);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Armature_getFlipX);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Armature_intersectsSegment);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Armature_setCacheFrameRate);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Armature__addConstraint);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Armature_setFlipY);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Armature_setFlipX);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Armature__addSlot);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Armature_advanceTime);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Armature_getAnimation);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Armature_getParent);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Armature_getArmatureData);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Armature_getEventDispatcher);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Armature_containsPoint);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Armature_getProxy);
+
+extern se::Object* __jsb_dragonBones_TransformObject_proto;
+extern se::Class* __jsb_dragonBones_TransformObject_class;
+
+bool js_register_dragonBones_TransformObject(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_TransformObject_getOffset);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_TransformObject_getGlobal);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_TransformObject_getOrigin);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_TransformObject_getGlobalTransformMatrix);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_TransformObject_getArmature);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_TransformObject_updateGlobalTransform);
+
+extern se::Object* __jsb_dragonBones_AnimationState_proto;
+extern se::Class* __jsb_dragonBones_AnimationState_class;
+
+bool js_register_dragonBones_AnimationState(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_AnimationState_isCompleted);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_AnimationState_play);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_AnimationState_fadeOut);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_AnimationState_getName);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_AnimationState_stop);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_AnimationState_setCurrentTime);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_AnimationState_getCurrentTime);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_AnimationState_getTotalTime);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_AnimationState_init);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_AnimationState_isFadeIn);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_AnimationState_addBoneMask);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_AnimationState_containsBoneMask);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_AnimationState_removeAllBoneMask);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_AnimationState_getAnimationData);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_AnimationState_isFadeComplete);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_AnimationState_advanceTime);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_AnimationState_isPlaying);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_AnimationState_removeBoneMask);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_AnimationState_getCurrentPlayTimes);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_AnimationState_isFadeOut);
+
+extern se::Object* __jsb_dragonBones_Bone_proto;
+extern se::Class* __jsb_dragonBones_Bone_class;
+
+bool js_register_dragonBones_Bone(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Bone_getOffsetMode);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Bone_getParent);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Bone_getName);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Bone_contains);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Bone_update);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Bone_updateByConstraint);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Bone_getVisible);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Bone_init);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Bone_invalidUpdate);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Bone_setOffsetMode);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Bone_setVisible);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Bone_getBoneData);
+
+extern se::Object* __jsb_dragonBones_Slot_proto;
+extern se::Class* __jsb_dragonBones_Slot_class;
+
+bool js_register_dragonBones_Slot(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Slot__updateColor);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Slot_setRawDisplayDatas);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Slot_getVisible);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Slot_getSlotData);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Slot_getName);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Slot__setZorder);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Slot_invalidUpdate);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Slot_getChildArmature);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Slot_intersectsSegment);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Slot_update);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Slot_updateTransformAndMatrix);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Slot_getParent);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Slot_getBoundingBoxData);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Slot_setChildArmature);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Slot_replaceDisplayData);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Slot_containsPoint);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Slot_setVisible);
+
+extern se::Object* __jsb_dragonBones_WorldClock_proto;
+extern se::Class* __jsb_dragonBones_WorldClock_class;
+
+bool js_register_dragonBones_WorldClock(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_WorldClock_render);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_WorldClock_clear);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_WorldClock_contains);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_WorldClock_getClock);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_WorldClock_advanceTime);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_WorldClock_setClock);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_WorldClock_getStaticClock);
+
+extern se::Object* __jsb_dragonBones_Animation_proto;
+extern se::Class* __jsb_dragonBones_Animation_class;
+
+bool js_register_dragonBones_Animation(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Animation_init);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Animation_gotoAndPlayByTime);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Animation_fadeIn);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Animation_playConfig);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Animation_isCompleted);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Animation_play);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Animation_getState);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Animation_stop);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Animation_getLastAnimationName);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Animation_getLastAnimationState);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Animation_getAnimationNames);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Animation_advanceTime);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Animation_isPlaying);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Animation_gotoAndPlayByProgress);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Animation_getAnimationConfig);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Animation_reset);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Animation_hasAnimation);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Animation_gotoAndStopByTime);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Animation_gotoAndStopByProgress);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Animation_gotoAndPlayByFrame);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_Animation_gotoAndStopByFrame);
+
+extern se::Object* __jsb_dragonBones_EventObject_proto;
+extern se::Class* __jsb_dragonBones_EventObject_class;
+
+bool js_register_dragonBones_EventObject(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_EventObject_getBone);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_EventObject_getData);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_EventObject_getAnimationState);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_EventObject_getArmature);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_EventObject_getSlot);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_EventObject_actionDataToInstance);
+
+extern se::Object* __jsb_dragonBones_BaseFactory_proto;
+extern se::Class* __jsb_dragonBones_BaseFactory_class;
+
+bool js_register_dragonBones_BaseFactory(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_BaseFactory_replaceSkin);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_BaseFactory_replaceAnimation);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_BaseFactory_getClock);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_BaseFactory_removeDragonBonesData);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_BaseFactory_removeTextureAtlasData);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_BaseFactory_parseDragonBonesData);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_BaseFactory_clear);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_BaseFactory_addDragonBonesData);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_BaseFactory_buildArmature);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_BaseFactory_addTextureAtlasData);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_BaseFactory_getArmatureData);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_BaseFactory_replaceSlotDisplay);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_BaseFactory_changeSkin);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_BaseFactory_replaceDisplay);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_BaseFactory_getDragonBonesData);
+
+extern se::Object* __jsb_dragonBones_CCTextureAtlasData_proto;
+extern se::Class* __jsb_dragonBones_CCTextureAtlasData_class;
+
+bool js_register_dragonBones_CCTextureAtlasData(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCTextureAtlasData_setRenderTexture);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCTextureAtlasData_getRenderTexture);
+
+extern se::Object* __jsb_dragonBones_CCTextureData_proto;
+extern se::Class* __jsb_dragonBones_CCTextureData_class;
+
+bool js_register_dragonBones_CCTextureData(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+
+extern se::Object* __jsb_dragonBones_CCSlot_proto;
+extern se::Class* __jsb_dragonBones_CCSlot_class;
+
+bool js_register_dragonBones_CCSlot(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCSlot_getTexture);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCSlot_updateWorldMatrix);
+
+extern se::Object* __jsb_dragonBones_CCArmatureDisplay_proto;
+extern se::Class* __jsb_dragonBones_CCArmatureDisplay_class;
+
+bool js_register_dragonBones_CCArmatureDisplay(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureDisplay_dbInit);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureDisplay_addDBEventListener);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureDisplay_getRootDisplay);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureDisplay_setAttachUtil);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureDisplay_removeDBEventListener);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureDisplay_setEffect);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureDisplay_dispose);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureDisplay_setOpacityModifyRGB);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureDisplay_dbClear);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureDisplay_dispatchDBEvent);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureDisplay_getDebugData);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureDisplay_hasDBEventListener);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureDisplay_dbUpdate);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureDisplay_setDBEventCallback);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureDisplay_setDebugBonesEnabled);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureDisplay_getAnimation);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureDisplay_setColor);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureDisplay_bindNodeProxy);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureDisplay_setBatchEnabled);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureDisplay_dbRender);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureDisplay_getArmature);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureDisplay_convertToRootSpace);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureDisplay_create);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureDisplay_CCArmatureDisplay);
+
+extern se::Object* __jsb_dragonBones_CCFactory_proto;
+extern se::Class* __jsb_dragonBones_CCFactory_class;
+
+bool js_register_dragonBones_CCFactory(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCFactory_setTimeScale);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCFactory_getSoundEventManager);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCFactory_render);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCFactory_removeDragonBonesDataByUUID);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCFactory_update);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCFactory_remove);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCFactory_getTextureAtlasDataByIndex);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCFactory_getDragonBones);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCFactory_parseDragonBonesDataByPath);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCFactory_add);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCFactory_buildArmatureDisplay);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCFactory_stopSchedule);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCFactory_removeTextureAtlasDataByIndex);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCFactory_getTimeScale);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCFactory_isInit);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCFactory_destroyFactory);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCFactory_getClock);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCFactory_getFactory);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCFactory_CCFactory);
+
+extern se::Object* __jsb_dragonBones_ArmatureCacheMgr_proto;
+extern se::Class* __jsb_dragonBones_ArmatureCacheMgr_class;
+
+bool js_register_dragonBones_ArmatureCacheMgr(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_ArmatureCacheMgr_removeArmatureCache);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_ArmatureCacheMgr_buildArmatureCache);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_ArmatureCacheMgr_destroyInstance);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_ArmatureCacheMgr_getInstance);
+
+extern se::Object* __jsb_dragonBones_CCArmatureCacheDisplay_proto;
+extern se::Class* __jsb_dragonBones_CCArmatureCacheDisplay_class;
+
+bool js_register_dragonBones_CCArmatureCacheDisplay(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureCacheDisplay_setTimeScale);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureCacheDisplay_render);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureCacheDisplay_addDBEventListener);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureCacheDisplay_setAttachUtil);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureCacheDisplay_removeDBEventListener);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureCacheDisplay_onEnable);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureCacheDisplay_setEffect);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureCacheDisplay_dispose);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureCacheDisplay_setOpacityModifyRGB);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureCacheDisplay_dispatchDBEvent);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureCacheDisplay_beginSchedule);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureCacheDisplay_updateAllAnimationCache);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureCacheDisplay_update);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureCacheDisplay_playAnimation);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureCacheDisplay_setDBEventCallback);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureCacheDisplay_updateAnimationCache);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureCacheDisplay_getTimeScale);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureCacheDisplay_getAnimation);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureCacheDisplay_onDisable);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureCacheDisplay_setColor);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureCacheDisplay_bindNodeProxy);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureCacheDisplay_setBatchEnabled);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureCacheDisplay_getArmature);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureCacheDisplay_stopSchedule);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CCArmatureCacheDisplay_CCArmatureCacheDisplay);
+
+extern se::Object* __jsb_dragonBones_AttachUtilBase_proto;
+extern se::Class* __jsb_dragonBones_AttachUtilBase_class;
+
+bool js_register_dragonBones_AttachUtilBase(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_AttachUtilBase_associateAttachedNode);
+
+extern se::Object* __jsb_dragonBones_RealTimeAttachUtil_proto;
+extern se::Class* __jsb_dragonBones_RealTimeAttachUtil_class;
+
+bool js_register_dragonBones_RealTimeAttachUtil(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_RealTimeAttachUtil_RealTimeAttachUtil);
+
+extern se::Object* __jsb_dragonBones_CacheModeAttachUtil_proto;
+extern se::Class* __jsb_dragonBones_CacheModeAttachUtil_class;
+
+bool js_register_dragonBones_CacheModeAttachUtil(se::Object* obj);
+bool register_all_cocos2dx_dragonbones(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_dragonbones_CacheModeAttachUtil_CacheModeAttachUtil);
+
+#endif //#if USE_DRAGONBONES > 0

cocos2d-x/cocos/scripting/js-bindings/auto/jsb_cocos2dx_editor_support_auto.cpp

@@ -0,0 +1,429 @@
+#include "scripting/js-bindings/auto/jsb_cocos2dx_editor_support_auto.hpp"
+#if USE_MIDDLEWARE > 0
+#include "scripting/js-bindings/manual/jsb_conversions.hpp"
+#include "scripting/js-bindings/manual/jsb_global.h"
+#include "editor-support/middleware-adapter.h"
+#include "editor-support/MiddlewareManager.h"
+
+se::Object* __jsb_cocos2d_middleware_Texture2D_proto = nullptr;
+se::Class* __jsb_cocos2d_middleware_Texture2D_class = nullptr;
+
+static bool js_cocos2dx_editor_support_Texture2D_getRealTextureIndex(se::State& s)
+{
+    cocos2d::middleware::Texture2D* cobj = (cocos2d::middleware::Texture2D*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_cocos2dx_editor_support_Texture2D_getRealTextureIndex : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 0) {
+        int result = cobj->getRealTextureIndex();
+        ok &= int32_to_seval(result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_cocos2dx_editor_support_Texture2D_getRealTextureIndex : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_cocos2dx_editor_support_Texture2D_getRealTextureIndex)
+
+static bool js_cocos2dx_editor_support_Texture2D_setTexParamCallback(se::State& s)
+{
+    cocos2d::middleware::Texture2D* cobj = (cocos2d::middleware::Texture2D*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_cocos2dx_editor_support_Texture2D_setTexParamCallback : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        std::function<void (int, unsigned int, unsigned int, unsigned int, unsigned int)> arg0;
+        do {
+            if (args[0].isObject() && args[0].toObject()->isFunction())
+            {
+                se::Value jsThis(s.thisObject());
+                se::Value jsFunc(args[0]);
+                jsThis.toObject()->attachObject(jsFunc.toObject());
+                auto lambda = [=](int larg0, unsigned int larg1, unsigned int larg2, unsigned int larg3, unsigned int larg4) -> void {
+                    se::ScriptEngine::getInstance()->clearException();
+                    se::AutoHandleScope hs;
+        
+                    CC_UNUSED bool ok = true;
+                    se::ValueArray args;
+                    args.resize(5);
+                    ok &= int32_to_seval(larg0, &args[0]);
+                    ok &= uint32_to_seval(larg1, &args[1]);
+                    ok &= uint32_to_seval(larg2, &args[2]);
+                    ok &= uint32_to_seval(larg3, &args[3]);
+                    ok &= uint32_to_seval(larg4, &args[4]);
+                    se::Value rval;
+                    se::Object* thisObj = jsThis.isObject() ? jsThis.toObject() : nullptr;
+                    se::Object* funcObj = jsFunc.toObject();
+                    bool succeed = funcObj->call(args, thisObj, &rval);
+                    if (!succeed) {
+                        se::ScriptEngine::getInstance()->clearException();
+                    }
+                };
+                arg0 = lambda;
+            }
+            else
+            {
+                arg0 = nullptr;
+            }
+        } while(false)
+        ;
+        SE_PRECONDITION2(ok, false, "js_cocos2dx_editor_support_Texture2D_setTexParamCallback : Error processing arguments");
+        cobj->setTexParamCallback(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_cocos2dx_editor_support_Texture2D_setTexParamCallback)
+
+static bool js_cocos2dx_editor_support_Texture2D_setPixelsHigh(se::State& s)
+{
+    cocos2d::middleware::Texture2D* cobj = (cocos2d::middleware::Texture2D*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_cocos2dx_editor_support_Texture2D_setPixelsHigh : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        int arg0 = 0;
+        do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (int)tmp; } while(false);
+        SE_PRECONDITION2(ok, false, "js_cocos2dx_editor_support_Texture2D_setPixelsHigh : Error processing arguments");
+        cobj->setPixelsHigh(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_cocos2dx_editor_support_Texture2D_setPixelsHigh)
+
+static bool js_cocos2dx_editor_support_Texture2D_getNativeTexture(se::State& s)
+{
+    cocos2d::middleware::Texture2D* cobj = (cocos2d::middleware::Texture2D*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_cocos2dx_editor_support_Texture2D_getNativeTexture : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 0) {
+        cocos2d::renderer::Texture* result = cobj->getNativeTexture();
+        ok &= native_ptr_to_seval<cocos2d::renderer::Texture>((cocos2d::renderer::Texture*)result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_cocos2dx_editor_support_Texture2D_getNativeTexture : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_cocos2dx_editor_support_Texture2D_getNativeTexture)
+
+static bool js_cocos2dx_editor_support_Texture2D_setPixelsWide(se::State& s)
+{
+    cocos2d::middleware::Texture2D* cobj = (cocos2d::middleware::Texture2D*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_cocos2dx_editor_support_Texture2D_setPixelsWide : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        int arg0 = 0;
+        do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (int)tmp; } while(false);
+        SE_PRECONDITION2(ok, false, "js_cocos2dx_editor_support_Texture2D_setPixelsWide : Error processing arguments");
+        cobj->setPixelsWide(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_cocos2dx_editor_support_Texture2D_setPixelsWide)
+
+static bool js_cocos2dx_editor_support_Texture2D_getPixelsHigh(se::State& s)
+{
+    cocos2d::middleware::Texture2D* cobj = (cocos2d::middleware::Texture2D*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_cocos2dx_editor_support_Texture2D_getPixelsHigh : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 0) {
+        int result = cobj->getPixelsHigh();
+        ok &= int32_to_seval(result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_cocos2dx_editor_support_Texture2D_getPixelsHigh : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_cocos2dx_editor_support_Texture2D_getPixelsHigh)
+
+static bool js_cocos2dx_editor_support_Texture2D_getPixelsWide(se::State& s)
+{
+    cocos2d::middleware::Texture2D* cobj = (cocos2d::middleware::Texture2D*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_cocos2dx_editor_support_Texture2D_getPixelsWide : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 0) {
+        int result = cobj->getPixelsWide();
+        ok &= int32_to_seval(result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_cocos2dx_editor_support_Texture2D_getPixelsWide : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_cocos2dx_editor_support_Texture2D_getPixelsWide)
+
+static bool js_cocos2dx_editor_support_Texture2D_setRealTextureIndex(se::State& s)
+{
+    cocos2d::middleware::Texture2D* cobj = (cocos2d::middleware::Texture2D*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_cocos2dx_editor_support_Texture2D_setRealTextureIndex : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        int arg0 = 0;
+        do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (int)tmp; } while(false);
+        SE_PRECONDITION2(ok, false, "js_cocos2dx_editor_support_Texture2D_setRealTextureIndex : Error processing arguments");
+        cobj->setRealTextureIndex(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_cocos2dx_editor_support_Texture2D_setRealTextureIndex)
+
+static bool js_cocos2dx_editor_support_Texture2D_setNativeTexture(se::State& s)
+{
+    cocos2d::middleware::Texture2D* cobj = (cocos2d::middleware::Texture2D*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_cocos2dx_editor_support_Texture2D_setNativeTexture : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        cocos2d::renderer::Texture* arg0 = nullptr;
+        ok &= seval_to_native_ptr(args[0], &arg0);
+        SE_PRECONDITION2(ok, false, "js_cocos2dx_editor_support_Texture2D_setNativeTexture : Error processing arguments");
+        cobj->setNativeTexture(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_cocos2dx_editor_support_Texture2D_setNativeTexture)
+
+static bool js_cocos2dx_editor_support_Texture2D_setTexParameters(se::State& s)
+{
+    cocos2d::middleware::Texture2D* cobj = (cocos2d::middleware::Texture2D*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_cocos2dx_editor_support_Texture2D_setTexParameters : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        cocos2d::middleware::Texture2D::_TexParams arg0;
+        #pragma warning NO CONVERSION TO NATIVE FOR _TexParams
+        ok = false;
+        SE_PRECONDITION2(ok, false, "js_cocos2dx_editor_support_Texture2D_setTexParameters : Error processing arguments");
+        cobj->setTexParameters(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_cocos2dx_editor_support_Texture2D_setTexParameters)
+
+SE_DECLARE_FINALIZE_FUNC(js_cocos2d_middleware_Texture2D_finalize)
+
+static bool js_cocos2dx_editor_support_Texture2D_constructor(se::State& s)
+{
+    cocos2d::middleware::Texture2D* cobj = new (std::nothrow) cocos2d::middleware::Texture2D();
+    s.thisObject()->setPrivateData(cobj);
+    return true;
+}
+SE_BIND_CTOR(js_cocos2dx_editor_support_Texture2D_constructor, __jsb_cocos2d_middleware_Texture2D_class, js_cocos2d_middleware_Texture2D_finalize)
+
+
+
+
+static bool js_cocos2d_middleware_Texture2D_finalize(se::State& s)
+{
+    CCLOGINFO("jsbindings: finalizing JS object %p (cocos2d::middleware::Texture2D)", s.nativeThisObject());
+    cocos2d::middleware::Texture2D* cobj = (cocos2d::middleware::Texture2D*)s.nativeThisObject();
+    cobj->release();
+    return true;
+}
+SE_BIND_FINALIZE_FUNC(js_cocos2d_middleware_Texture2D_finalize)
+
+bool js_register_cocos2dx_editor_support_Texture2D(se::Object* obj)
+{
+    auto cls = se::Class::create("Texture2D", obj, nullptr, _SE(js_cocos2dx_editor_support_Texture2D_constructor));
+
+    cls->defineFunction("getRealTextureIndex", _SE(js_cocos2dx_editor_support_Texture2D_getRealTextureIndex));
+    cls->defineFunction("setTexParamCallback", _SE(js_cocos2dx_editor_support_Texture2D_setTexParamCallback));
+    cls->defineFunction("setPixelsHigh", _SE(js_cocos2dx_editor_support_Texture2D_setPixelsHigh));
+    cls->defineFunction("getNativeTexture", _SE(js_cocos2dx_editor_support_Texture2D_getNativeTexture));
+    cls->defineFunction("setPixelsWide", _SE(js_cocos2dx_editor_support_Texture2D_setPixelsWide));
+    cls->defineFunction("getPixelsHigh", _SE(js_cocos2dx_editor_support_Texture2D_getPixelsHigh));
+    cls->defineFunction("getPixelsWide", _SE(js_cocos2dx_editor_support_Texture2D_getPixelsWide));
+    cls->defineFunction("setRealTextureIndex", _SE(js_cocos2dx_editor_support_Texture2D_setRealTextureIndex));
+    cls->defineFunction("setNativeTexture", _SE(js_cocos2dx_editor_support_Texture2D_setNativeTexture));
+    cls->defineFunction("setTexParameters", _SE(js_cocos2dx_editor_support_Texture2D_setTexParameters));
+    cls->defineFinalizeFunction(_SE(js_cocos2d_middleware_Texture2D_finalize));
+    cls->install();
+    JSBClassType::registerClass<cocos2d::middleware::Texture2D>(cls);
+
+    __jsb_cocos2d_middleware_Texture2D_proto = cls->getProto();
+    __jsb_cocos2d_middleware_Texture2D_class = cls;
+
+    se::ScriptEngine::getInstance()->clearException();
+    return true;
+}
+
+se::Object* __jsb_cocos2d_middleware_MiddlewareManager_proto = nullptr;
+se::Class* __jsb_cocos2d_middleware_MiddlewareManager_class = nullptr;
+
+static bool js_cocos2dx_editor_support_MiddlewareManager_render(se::State& s)
+{
+    cocos2d::middleware::MiddlewareManager* cobj = (cocos2d::middleware::MiddlewareManager*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_cocos2dx_editor_support_MiddlewareManager_render : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        float arg0 = 0;
+        ok &= seval_to_float(args[0], &arg0);
+        SE_PRECONDITION2(ok, false, "js_cocos2dx_editor_support_MiddlewareManager_render : Error processing arguments");
+        cobj->render(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_cocos2dx_editor_support_MiddlewareManager_render)
+
+static bool js_cocos2dx_editor_support_MiddlewareManager_update(se::State& s)
+{
+    cocos2d::middleware::MiddlewareManager* cobj = (cocos2d::middleware::MiddlewareManager*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_cocos2dx_editor_support_MiddlewareManager_update : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        float arg0 = 0;
+        ok &= seval_to_float(args[0], &arg0);
+        SE_PRECONDITION2(ok, false, "js_cocos2dx_editor_support_MiddlewareManager_update : Error processing arguments");
+        cobj->update(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_cocos2dx_editor_support_MiddlewareManager_update)
+
+static bool js_cocos2dx_editor_support_MiddlewareManager_destroyInstance(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    if (argc == 0) {
+        cocos2d::middleware::MiddlewareManager::destroyInstance();
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_cocos2dx_editor_support_MiddlewareManager_destroyInstance)
+
+static bool js_cocos2dx_editor_support_MiddlewareManager_generateModuleID(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 0) {
+        uint8_t result = cocos2d::middleware::MiddlewareManager::generateModuleID();
+        ok &= uint8_to_seval(result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_cocos2dx_editor_support_MiddlewareManager_generateModuleID : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_cocos2dx_editor_support_MiddlewareManager_generateModuleID)
+
+static bool js_cocos2dx_editor_support_MiddlewareManager_getInstance(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 0) {
+        cocos2d::middleware::MiddlewareManager* result = cocos2d::middleware::MiddlewareManager::getInstance();
+        ok &= native_ptr_to_seval<cocos2d::middleware::MiddlewareManager>((cocos2d::middleware::MiddlewareManager*)result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_cocos2dx_editor_support_MiddlewareManager_getInstance : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_cocos2dx_editor_support_MiddlewareManager_getInstance)
+
+SE_DECLARE_FINALIZE_FUNC(js_cocos2d_middleware_MiddlewareManager_finalize)
+
+static bool js_cocos2dx_editor_support_MiddlewareManager_constructor(se::State& s)
+{
+    cocos2d::middleware::MiddlewareManager* cobj = new (std::nothrow) cocos2d::middleware::MiddlewareManager();
+    s.thisObject()->setPrivateData(cobj);
+    se::NonRefNativePtrCreatedByCtorMap::emplace(cobj);
+    return true;
+}
+SE_BIND_CTOR(js_cocos2dx_editor_support_MiddlewareManager_constructor, __jsb_cocos2d_middleware_MiddlewareManager_class, js_cocos2d_middleware_MiddlewareManager_finalize)
+
+
+
+
+static bool js_cocos2d_middleware_MiddlewareManager_finalize(se::State& s)
+{
+    CCLOGINFO("jsbindings: finalizing JS object %p (cocos2d::middleware::MiddlewareManager)", s.nativeThisObject());
+    auto iter = se::NonRefNativePtrCreatedByCtorMap::find(s.nativeThisObject());
+    if (iter != se::NonRefNativePtrCreatedByCtorMap::end())
+    {
+        se::NonRefNativePtrCreatedByCtorMap::erase(iter);
+        cocos2d::middleware::MiddlewareManager* cobj = (cocos2d::middleware::MiddlewareManager*)s.nativeThisObject();
+        delete cobj;
+    }
+    return true;
+}
+SE_BIND_FINALIZE_FUNC(js_cocos2d_middleware_MiddlewareManager_finalize)
+
+bool js_register_cocos2dx_editor_support_MiddlewareManager(se::Object* obj)
+{
+    auto cls = se::Class::create("MiddlewareManager", obj, nullptr, _SE(js_cocos2dx_editor_support_MiddlewareManager_constructor));
+
+    cls->defineFunction("render", _SE(js_cocos2dx_editor_support_MiddlewareManager_render));
+    cls->defineFunction("update", _SE(js_cocos2dx_editor_support_MiddlewareManager_update));
+    cls->defineStaticFunction("destroyInstance", _SE(js_cocos2dx_editor_support_MiddlewareManager_destroyInstance));
+    cls->defineStaticFunction("generateModuleID", _SE(js_cocos2dx_editor_support_MiddlewareManager_generateModuleID));
+    cls->defineStaticFunction("getInstance", _SE(js_cocos2dx_editor_support_MiddlewareManager_getInstance));
+    cls->defineFinalizeFunction(_SE(js_cocos2d_middleware_MiddlewareManager_finalize));
+    cls->install();
+    JSBClassType::registerClass<cocos2d::middleware::MiddlewareManager>(cls);
+
+    __jsb_cocos2d_middleware_MiddlewareManager_proto = cls->getProto();
+    __jsb_cocos2d_middleware_MiddlewareManager_class = cls;
+
+    se::ScriptEngine::getInstance()->clearException();
+    return true;
+}
+
+bool register_all_cocos2dx_editor_support(se::Object* obj)
+{
+    // Get the ns
+    se::Value nsVal;
+    if (!obj->getProperty("middleware", &nsVal))
+    {
+        se::HandleObject jsobj(se::Object::createPlainObject());
+        nsVal.setObject(jsobj);
+        obj->setProperty("middleware", nsVal);
+    }
+    se::Object* ns = nsVal.toObject();
+
+    js_register_cocos2dx_editor_support_MiddlewareManager(ns);
+    js_register_cocos2dx_editor_support_Texture2D(ns);
+    return true;
+}
+
+#endif //#if USE_MIDDLEWARE > 0

cocos2d-x/cocos/scripting/js-bindings/auto/jsb_cocos2dx_editor_support_auto.hpp

@@ -0,0 +1,36 @@
+#pragma once
+#include "base/ccConfig.h"
+#if USE_MIDDLEWARE > 0
+
+#include "cocos/scripting/js-bindings/jswrapper/SeApi.h"
+
+extern se::Object* __jsb_cocos2d_middleware_Texture2D_proto;
+extern se::Class* __jsb_cocos2d_middleware_Texture2D_class;
+
+bool js_register_cocos2d_middleware_Texture2D(se::Object* obj);
+bool register_all_cocos2dx_editor_support(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_editor_support_Texture2D_getRealTextureIndex);
+SE_DECLARE_FUNC(js_cocos2dx_editor_support_Texture2D_setTexParamCallback);
+SE_DECLARE_FUNC(js_cocos2dx_editor_support_Texture2D_setPixelsHigh);
+SE_DECLARE_FUNC(js_cocos2dx_editor_support_Texture2D_getNativeTexture);
+SE_DECLARE_FUNC(js_cocos2dx_editor_support_Texture2D_setPixelsWide);
+SE_DECLARE_FUNC(js_cocos2dx_editor_support_Texture2D_getPixelsHigh);
+SE_DECLARE_FUNC(js_cocos2dx_editor_support_Texture2D_getPixelsWide);
+SE_DECLARE_FUNC(js_cocos2dx_editor_support_Texture2D_setRealTextureIndex);
+SE_DECLARE_FUNC(js_cocos2dx_editor_support_Texture2D_setNativeTexture);
+SE_DECLARE_FUNC(js_cocos2dx_editor_support_Texture2D_setTexParameters);
+SE_DECLARE_FUNC(js_cocos2dx_editor_support_Texture2D_Texture2D);
+
+extern se::Object* __jsb_cocos2d_middleware_MiddlewareManager_proto;
+extern se::Class* __jsb_cocos2d_middleware_MiddlewareManager_class;
+
+bool js_register_cocos2d_middleware_MiddlewareManager(se::Object* obj);
+bool register_all_cocos2dx_editor_support(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_editor_support_MiddlewareManager_render);
+SE_DECLARE_FUNC(js_cocos2dx_editor_support_MiddlewareManager_update);
+SE_DECLARE_FUNC(js_cocos2dx_editor_support_MiddlewareManager_destroyInstance);
+SE_DECLARE_FUNC(js_cocos2dx_editor_support_MiddlewareManager_generateModuleID);
+SE_DECLARE_FUNC(js_cocos2dx_editor_support_MiddlewareManager_getInstance);
+SE_DECLARE_FUNC(js_cocos2dx_editor_support_MiddlewareManager_MiddlewareManager);
+
+#endif //#if USE_MIDDLEWARE > 0

cocos2d-x/cocos/scripting/js-bindings/auto/jsb_cocos2dx_extension_auto.hpp

@@ -0,0 +1,73 @@
+#pragma once
+#include "base/ccConfig.h"
+
+#include "cocos/scripting/js-bindings/jswrapper/SeApi.h"
+
+extern se::Object* __jsb_cocos2d_extension_EventAssetsManagerEx_proto;
+extern se::Class* __jsb_cocos2d_extension_EventAssetsManagerEx_class;
+
+bool js_register_cocos2d_extension_EventAssetsManagerEx(se::Object* obj);
+bool register_all_extension(se::Object* obj);
+SE_DECLARE_FUNC(js_extension_EventAssetsManagerEx_getAssetsManagerEx);
+SE_DECLARE_FUNC(js_extension_EventAssetsManagerEx_getDownloadedFiles);
+SE_DECLARE_FUNC(js_extension_EventAssetsManagerEx_getTotalFiles);
+SE_DECLARE_FUNC(js_extension_EventAssetsManagerEx_getAssetId);
+SE_DECLARE_FUNC(js_extension_EventAssetsManagerEx_getTotalBytes);
+SE_DECLARE_FUNC(js_extension_EventAssetsManagerEx_getCURLECode);
+SE_DECLARE_FUNC(js_extension_EventAssetsManagerEx_getMessage);
+SE_DECLARE_FUNC(js_extension_EventAssetsManagerEx_getCURLMCode);
+SE_DECLARE_FUNC(js_extension_EventAssetsManagerEx_getDownloadedBytes);
+SE_DECLARE_FUNC(js_extension_EventAssetsManagerEx_getPercentByFile);
+SE_DECLARE_FUNC(js_extension_EventAssetsManagerEx_getEventCode);
+SE_DECLARE_FUNC(js_extension_EventAssetsManagerEx_getPercent);
+SE_DECLARE_FUNC(js_extension_EventAssetsManagerEx_isResuming);
+SE_DECLARE_FUNC(js_extension_EventAssetsManagerEx_EventAssetsManagerEx);
+
+extern se::Object* __jsb_cocos2d_extension_Manifest_proto;
+extern se::Class* __jsb_cocos2d_extension_Manifest_class;
+
+bool js_register_cocos2d_extension_Manifest(se::Object* obj);
+bool register_all_extension(se::Object* obj);
+SE_DECLARE_FUNC(js_extension_Manifest_getManifestRoot);
+SE_DECLARE_FUNC(js_extension_Manifest_setUpdating);
+SE_DECLARE_FUNC(js_extension_Manifest_getManifestFileUrl);
+SE_DECLARE_FUNC(js_extension_Manifest_isVersionLoaded);
+SE_DECLARE_FUNC(js_extension_Manifest_parseFile);
+SE_DECLARE_FUNC(js_extension_Manifest_isLoaded);
+SE_DECLARE_FUNC(js_extension_Manifest_getPackageUrl);
+SE_DECLARE_FUNC(js_extension_Manifest_isUpdating);
+SE_DECLARE_FUNC(js_extension_Manifest_getVersion);
+SE_DECLARE_FUNC(js_extension_Manifest_parseJSONString);
+SE_DECLARE_FUNC(js_extension_Manifest_getVersionFileUrl);
+SE_DECLARE_FUNC(js_extension_Manifest_getSearchPaths);
+SE_DECLARE_FUNC(js_extension_Manifest_Manifest);
+
+extern se::Object* __jsb_cocos2d_extension_AssetsManagerEx_proto;
+extern se::Class* __jsb_cocos2d_extension_AssetsManagerEx_class;
+
+bool js_register_cocos2d_extension_AssetsManagerEx(se::Object* obj);
+bool register_all_extension(se::Object* obj);
+SE_DECLARE_FUNC(js_extension_AssetsManagerEx_getDownloadedFiles);
+SE_DECLARE_FUNC(js_extension_AssetsManagerEx_setEventCallback);
+SE_DECLARE_FUNC(js_extension_AssetsManagerEx_downloadFailedAssets);
+SE_DECLARE_FUNC(js_extension_AssetsManagerEx_getTotalFiles);
+SE_DECLARE_FUNC(js_extension_AssetsManagerEx_checkUpdate);
+SE_DECLARE_FUNC(js_extension_AssetsManagerEx_loadLocalManifest);
+SE_DECLARE_FUNC(js_extension_AssetsManagerEx_setMaxConcurrentTask);
+SE_DECLARE_FUNC(js_extension_AssetsManagerEx_getLocalManifest);
+SE_DECLARE_FUNC(js_extension_AssetsManagerEx_getRemoteManifest);
+SE_DECLARE_FUNC(js_extension_AssetsManagerEx_cancelUpdate);
+SE_DECLARE_FUNC(js_extension_AssetsManagerEx_isResuming);
+SE_DECLARE_FUNC(js_extension_AssetsManagerEx_getState);
+SE_DECLARE_FUNC(js_extension_AssetsManagerEx_getMaxConcurrentTask);
+SE_DECLARE_FUNC(js_extension_AssetsManagerEx_setVersionCompareHandle);
+SE_DECLARE_FUNC(js_extension_AssetsManagerEx_getTotalBytes);
+SE_DECLARE_FUNC(js_extension_AssetsManagerEx_setVerifyCallback);
+SE_DECLARE_FUNC(js_extension_AssetsManagerEx_getStoragePath);
+SE_DECLARE_FUNC(js_extension_AssetsManagerEx_update);
+SE_DECLARE_FUNC(js_extension_AssetsManagerEx_getDownloadedBytes);
+SE_DECLARE_FUNC(js_extension_AssetsManagerEx_prepareUpdate);
+SE_DECLARE_FUNC(js_extension_AssetsManagerEx_loadRemoteManifest);
+SE_DECLARE_FUNC(js_extension_AssetsManagerEx_create);
+SE_DECLARE_FUNC(js_extension_AssetsManagerEx_AssetsManagerEx);
+

cocos2d-x/cocos/scripting/js-bindings/auto/jsb_cocos2dx_network_auto.cpp

@@ -0,0 +1,141 @@
+#include "scripting/js-bindings/auto/jsb_cocos2dx_network_auto.hpp"
+#if (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID || CC_TARGET_PLATFORM == CC_PLATFORM_IOS || CC_TARGET_PLATFORM == CC_PLATFORM_MAC || CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)
+#include "scripting/js-bindings/manual/jsb_conversions.hpp"
+#include "scripting/js-bindings/manual/jsb_global.h"
+#include "network/CCDownloader.h"
+
+se::Object* __jsb_cocos2d_network_Downloader_proto = nullptr;
+se::Class* __jsb_cocos2d_network_Downloader_class = nullptr;
+
+static bool js_network_Downloader_setOnTaskProgress(se::State& s)
+{
+    cocos2d::network::Downloader* cobj = (cocos2d::network::Downloader*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_network_Downloader_setOnTaskProgress : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        std::function<void (const cocos2d::network::DownloadTask &, long long, long long, long long)> arg0;
+        do {
+            if (args[0].isObject() && args[0].toObject()->isFunction())
+            {
+                se::Value jsThis(s.thisObject());
+                se::Value jsFunc(args[0]);
+                jsThis.toObject()->attachObject(jsFunc.toObject());
+                auto lambda = [=](const cocos2d::network::DownloadTask & larg0, long long larg1, long long larg2, long long larg3) -> void {
+                    se::ScriptEngine::getInstance()->clearException();
+                    se::AutoHandleScope hs;
+        
+                    CC_UNUSED bool ok = true;
+                    se::ValueArray args;
+                    args.resize(4);
+                    ok &= DownloadTask_to_seval(larg0, &args[0]);
+                    ok &= longlong_to_seval(larg1, &args[1]);
+                    ok &= longlong_to_seval(larg2, &args[2]);
+                    ok &= longlong_to_seval(larg3, &args[3]);
+                    se::Value rval;
+                    se::Object* thisObj = jsThis.isObject() ? jsThis.toObject() : nullptr;
+                    se::Object* funcObj = jsFunc.toObject();
+                    bool succeed = funcObj->call(args, thisObj, &rval);
+                    if (!succeed) {
+                        se::ScriptEngine::getInstance()->clearException();
+                    }
+                };
+                arg0 = lambda;
+            }
+            else
+            {
+                arg0 = nullptr;
+            }
+        } while(false)
+        ;
+        SE_PRECONDITION2(ok, false, "js_network_Downloader_setOnTaskProgress : Error processing arguments");
+        cobj->setOnTaskProgress(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_network_Downloader_setOnTaskProgress)
+
+SE_DECLARE_FINALIZE_FUNC(js_cocos2d_network_Downloader_finalize)
+
+static bool js_network_Downloader_constructor(se::State& s)
+{
+    CC_UNUSED bool ok = true;
+    const auto& args = s.args();
+    size_t argc = args.size();
+    do {
+        if (argc == 1) {
+            cocos2d::network::DownloaderHints arg0;
+            ok &= seval_to_DownloaderHints(args[0], &arg0);
+            if (!ok) { ok = true; break; }
+            cocos2d::network::Downloader* cobj = new (std::nothrow) cocos2d::network::Downloader(arg0);
+            s.thisObject()->setPrivateData(cobj);
+            se::NonRefNativePtrCreatedByCtorMap::emplace(cobj);
+            return true;
+        }
+    } while(false);
+    do {
+        if (argc == 0) {
+            cocos2d::network::Downloader* cobj = new (std::nothrow) cocos2d::network::Downloader();
+            s.thisObject()->setPrivateData(cobj);
+            se::NonRefNativePtrCreatedByCtorMap::emplace(cobj);
+            return true;
+        }
+    } while(false);
+    SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
+    return false;
+}
+SE_BIND_CTOR(js_network_Downloader_constructor, __jsb_cocos2d_network_Downloader_class, js_cocos2d_network_Downloader_finalize)
+
+
+
+
+static bool js_cocos2d_network_Downloader_finalize(se::State& s)
+{
+    CCLOGINFO("jsbindings: finalizing JS object %p (cocos2d::network::Downloader)", s.nativeThisObject());
+    auto iter = se::NonRefNativePtrCreatedByCtorMap::find(s.nativeThisObject());
+    if (iter != se::NonRefNativePtrCreatedByCtorMap::end())
+    {
+        se::NonRefNativePtrCreatedByCtorMap::erase(iter);
+        cocos2d::network::Downloader* cobj = (cocos2d::network::Downloader*)s.nativeThisObject();
+        delete cobj;
+    }
+    return true;
+}
+SE_BIND_FINALIZE_FUNC(js_cocos2d_network_Downloader_finalize)
+
+bool js_register_network_Downloader(se::Object* obj)
+{
+    auto cls = se::Class::create("Downloader", obj, nullptr, _SE(js_network_Downloader_constructor));
+
+    cls->defineFunction("setOnTaskProgress", _SE(js_network_Downloader_setOnTaskProgress));
+    cls->defineFinalizeFunction(_SE(js_cocos2d_network_Downloader_finalize));
+    cls->install();
+    JSBClassType::registerClass<cocos2d::network::Downloader>(cls);
+
+    __jsb_cocos2d_network_Downloader_proto = cls->getProto();
+    __jsb_cocos2d_network_Downloader_class = cls;
+
+    se::ScriptEngine::getInstance()->clearException();
+    return true;
+}
+
+bool register_all_network(se::Object* obj)
+{
+    // Get the ns
+    se::Value nsVal;
+    if (!obj->getProperty("jsb", &nsVal))
+    {
+        se::HandleObject jsobj(se::Object::createPlainObject());
+        nsVal.setObject(jsobj);
+        obj->setProperty("jsb", nsVal);
+    }
+    se::Object* ns = nsVal.toObject();
+
+    js_register_network_Downloader(ns);
+    return true;
+}
+
+#endif //#if (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID || CC_TARGET_PLATFORM == CC_PLATFORM_IOS || CC_TARGET_PLATFORM == CC_PLATFORM_MAC || CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)

cocos2d-x/cocos/scripting/js-bindings/auto/jsb_cocos2dx_network_auto.hpp

@@ -0,0 +1,15 @@
+#pragma once
+#include "base/ccConfig.h"
+#if (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID || CC_TARGET_PLATFORM == CC_PLATFORM_IOS || CC_TARGET_PLATFORM == CC_PLATFORM_MAC || CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)
+
+#include "cocos/scripting/js-bindings/jswrapper/SeApi.h"
+
+extern se::Object* __jsb_cocos2d_network_Downloader_proto;
+extern se::Class* __jsb_cocos2d_network_Downloader_class;
+
+bool js_register_cocos2d_network_Downloader(se::Object* obj);
+bool register_all_network(se::Object* obj);
+SE_DECLARE_FUNC(js_network_Downloader_setOnTaskProgress);
+SE_DECLARE_FUNC(js_network_Downloader_Downloader);
+
+#endif //#if (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID || CC_TARGET_PLATFORM == CC_PLATFORM_IOS || CC_TARGET_PLATFORM == CC_PLATFORM_MAC || CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)

cocos2d-x/cocos/scripting/js-bindings/auto/jsb_cocos2dx_particle_auto.hpp

@@ -0,0 +1,35 @@
+#pragma once
+#include "base/ccConfig.h"
+#if USE_PARTICLE > 0
+
+#include "cocos/scripting/js-bindings/jswrapper/SeApi.h"
+
+extern se::Object* __jsb_cocos2d_ParticleSimulator_proto;
+extern se::Class* __jsb_cocos2d_ParticleSimulator_class;
+
+bool js_register_cocos2d_ParticleSimulator(se::Object* obj);
+bool register_all_cocos2dx_particle(se::Object* obj);
+SE_DECLARE_FUNC(js_cocos2dx_particle_ParticleSimulator_setGravity);
+SE_DECLARE_FUNC(js_cocos2dx_particle_ParticleSimulator_render);
+SE_DECLARE_FUNC(js_cocos2dx_particle_ParticleSimulator_setSourcePos);
+SE_DECLARE_FUNC(js_cocos2dx_particle_ParticleSimulator_onEnable);
+SE_DECLARE_FUNC(js_cocos2dx_particle_ParticleSimulator_setEffect);
+SE_DECLARE_FUNC(js_cocos2dx_particle_ParticleSimulator_setPosVar);
+SE_DECLARE_FUNC(js_cocos2dx_particle_ParticleSimulator_setEndColorVar);
+SE_DECLARE_FUNC(js_cocos2dx_particle_ParticleSimulator_getParticleCount);
+SE_DECLARE_FUNC(js_cocos2dx_particle_ParticleSimulator_setStartColorVar);
+SE_DECLARE_FUNC(js_cocos2dx_particle_ParticleSimulator_emitParticle);
+SE_DECLARE_FUNC(js_cocos2dx_particle_ParticleSimulator_stop);
+SE_DECLARE_FUNC(js_cocos2dx_particle_ParticleSimulator_update);
+SE_DECLARE_FUNC(js_cocos2dx_particle_ParticleSimulator_active);
+SE_DECLARE_FUNC(js_cocos2dx_particle_ParticleSimulator_updateUVs);
+SE_DECLARE_FUNC(js_cocos2dx_particle_ParticleSimulator_setStartColor);
+SE_DECLARE_FUNC(js_cocos2dx_particle_ParticleSimulator_reset);
+SE_DECLARE_FUNC(js_cocos2dx_particle_ParticleSimulator_onDisable);
+SE_DECLARE_FUNC(js_cocos2dx_particle_ParticleSimulator_bindNodeProxy);
+SE_DECLARE_FUNC(js_cocos2dx_particle_ParticleSimulator_setEndColor);
+SE_DECLARE_FUNC(js_cocos2dx_particle_ParticleSimulator_setFinishedCallback);
+SE_DECLARE_FUNC(js_cocos2dx_particle_ParticleSimulator_setStopCallback);
+SE_DECLARE_FUNC(js_cocos2dx_particle_ParticleSimulator_ParticleSimulator);
+
+#endif //#if USE_PARTICLE > 0

cocos2d-x/cocos/scripting/js-bindings/auto/jsb_gfx_auto.hpp

@@ -0,0 +1,137 @@
+#pragma once
+#include "base/ccConfig.h"
+#if (USE_GFX_RENDERER > 0) && (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID || CC_TARGET_PLATFORM == CC_PLATFORM_IOS || CC_TARGET_PLATFORM == CC_PLATFORM_MAC || CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)
+
+#include "cocos/scripting/js-bindings/jswrapper/SeApi.h"
+
+extern se::Object* __jsb_cocos2d_renderer_GraphicsHandle_proto;
+extern se::Class* __jsb_cocos2d_renderer_GraphicsHandle_class;
+
+bool js_register_cocos2d_renderer_GraphicsHandle(se::Object* obj);
+bool register_all_gfx(se::Object* obj);
+SE_DECLARE_FUNC(js_gfx_GraphicsHandle_getHandle);
+SE_DECLARE_FUNC(js_gfx_GraphicsHandle_GraphicsHandle);
+
+extern se::Object* __jsb_cocos2d_renderer_IndexBuffer_proto;
+extern se::Class* __jsb_cocos2d_renderer_IndexBuffer_class;
+
+bool js_register_cocos2d_renderer_IndexBuffer(se::Object* obj);
+bool register_all_gfx(se::Object* obj);
+SE_DECLARE_FUNC(js_gfx_IndexBuffer_getUsage);
+SE_DECLARE_FUNC(js_gfx_IndexBuffer_setFormat);
+SE_DECLARE_FUNC(js_gfx_IndexBuffer_setCount);
+SE_DECLARE_FUNC(js_gfx_IndexBuffer_destroy);
+SE_DECLARE_FUNC(js_gfx_IndexBuffer_setUsage);
+SE_DECLARE_FUNC(js_gfx_IndexBuffer_getCount);
+SE_DECLARE_FUNC(js_gfx_IndexBuffer_setBytesPerIndex);
+SE_DECLARE_FUNC(js_gfx_IndexBuffer_getBytes);
+SE_DECLARE_FUNC(js_gfx_IndexBuffer_IndexBuffer);
+
+extern se::Object* __jsb_cocos2d_renderer_VertexBuffer_proto;
+extern se::Class* __jsb_cocos2d_renderer_VertexBuffer_class;
+
+bool js_register_cocos2d_renderer_VertexBuffer(se::Object* obj);
+bool register_all_gfx(se::Object* obj);
+SE_DECLARE_FUNC(js_gfx_VertexBuffer_getUsage);
+SE_DECLARE_FUNC(js_gfx_VertexBuffer_setCount);
+SE_DECLARE_FUNC(js_gfx_VertexBuffer_destroy);
+SE_DECLARE_FUNC(js_gfx_VertexBuffer_setUsage);
+SE_DECLARE_FUNC(js_gfx_VertexBuffer_getCount);
+SE_DECLARE_FUNC(js_gfx_VertexBuffer_getBytes);
+SE_DECLARE_FUNC(js_gfx_VertexBuffer_VertexBuffer);
+
+extern se::Object* __jsb_cocos2d_renderer_DeviceGraphics_proto;
+extern se::Class* __jsb_cocos2d_renderer_DeviceGraphics_class;
+
+bool js_register_cocos2d_renderer_DeviceGraphics(se::Object* obj);
+bool register_all_gfx(se::Object* obj);
+SE_DECLARE_FUNC(js_gfx_DeviceGraphics_setBlendFuncSeparate);
+SE_DECLARE_FUNC(js_gfx_DeviceGraphics_enableBlend);
+SE_DECLARE_FUNC(js_gfx_DeviceGraphics_setPrimitiveType);
+SE_DECLARE_FUNC(js_gfx_DeviceGraphics_setBlendEquationSeparate);
+SE_DECLARE_FUNC(js_gfx_DeviceGraphics_setIndexBuffer);
+SE_DECLARE_FUNC(js_gfx_DeviceGraphics_setProgram);
+SE_DECLARE_FUNC(js_gfx_DeviceGraphics_setFrameBuffer);
+SE_DECLARE_FUNC(js_gfx_DeviceGraphics_setStencilFunc);
+SE_DECLARE_FUNC(js_gfx_DeviceGraphics_setBlendColor);
+SE_DECLARE_FUNC(js_gfx_DeviceGraphics_setScissor);
+SE_DECLARE_FUNC(js_gfx_DeviceGraphics_setVertexBuffer);
+SE_DECLARE_FUNC(js_gfx_DeviceGraphics_enableDepthWrite);
+SE_DECLARE_FUNC(js_gfx_DeviceGraphics_getCapacity);
+SE_DECLARE_FUNC(js_gfx_DeviceGraphics_setStencilOpBack);
+SE_DECLARE_FUNC(js_gfx_DeviceGraphics_setViewport);
+SE_DECLARE_FUNC(js_gfx_DeviceGraphics_draw);
+SE_DECLARE_FUNC(js_gfx_DeviceGraphics_setDepthFunc);
+SE_DECLARE_FUNC(js_gfx_DeviceGraphics_enableDepthTest);
+SE_DECLARE_FUNC(js_gfx_DeviceGraphics_resetDrawCalls);
+SE_DECLARE_FUNC(js_gfx_DeviceGraphics_getDrawCalls);
+SE_DECLARE_FUNC(js_gfx_DeviceGraphics_setBlendEquation);
+SE_DECLARE_FUNC(js_gfx_DeviceGraphics_setStencilFuncFront);
+SE_DECLARE_FUNC(js_gfx_DeviceGraphics_setStencilOpFront);
+SE_DECLARE_FUNC(js_gfx_DeviceGraphics_setStencilFuncBack);
+SE_DECLARE_FUNC(js_gfx_DeviceGraphics_setBlendFunc);
+SE_DECLARE_FUNC(js_gfx_DeviceGraphics_setCullMode);
+SE_DECLARE_FUNC(js_gfx_DeviceGraphics_setStencilOp);
+SE_DECLARE_FUNC(js_gfx_DeviceGraphics_enableStencilTest);
+SE_DECLARE_FUNC(js_gfx_DeviceGraphics_destroy);
+SE_DECLARE_FUNC(js_gfx_DeviceGraphics_getInstance);
+
+extern se::Object* __jsb_cocos2d_renderer_FrameBuffer_proto;
+extern se::Class* __jsb_cocos2d_renderer_FrameBuffer_class;
+
+bool js_register_cocos2d_renderer_FrameBuffer(se::Object* obj);
+bool register_all_gfx(se::Object* obj);
+SE_DECLARE_FUNC(js_gfx_FrameBuffer_getHeight);
+SE_DECLARE_FUNC(js_gfx_FrameBuffer_getWidth);
+SE_DECLARE_FUNC(js_gfx_FrameBuffer_destroy);
+SE_DECLARE_FUNC(js_gfx_FrameBuffer_FrameBuffer);
+
+extern se::Object* __jsb_cocos2d_renderer_RenderTarget_proto;
+extern se::Class* __jsb_cocos2d_renderer_RenderTarget_class;
+
+bool js_register_cocos2d_renderer_RenderTarget(se::Object* obj);
+bool register_all_gfx(se::Object* obj);
+
+extern se::Object* __jsb_cocos2d_renderer_RenderBuffer_proto;
+extern se::Class* __jsb_cocos2d_renderer_RenderBuffer_class;
+
+bool js_register_cocos2d_renderer_RenderBuffer(se::Object* obj);
+bool register_all_gfx(se::Object* obj);
+SE_DECLARE_FUNC(js_gfx_RenderBuffer_init);
+SE_DECLARE_FUNC(js_gfx_RenderBuffer_update);
+SE_DECLARE_FUNC(js_gfx_RenderBuffer_create);
+SE_DECLARE_FUNC(js_gfx_RenderBuffer_RenderBuffer);
+
+extern se::Object* __jsb_cocos2d_renderer_Texture_proto;
+extern se::Class* __jsb_cocos2d_renderer_Texture_class;
+
+bool js_register_cocos2d_renderer_Texture(se::Object* obj);
+bool register_all_gfx(se::Object* obj);
+SE_DECLARE_FUNC(js_gfx_Texture_getWidth);
+SE_DECLARE_FUNC(js_gfx_Texture_setAlphaAtlas);
+SE_DECLARE_FUNC(js_gfx_Texture_getHeight);
+SE_DECLARE_FUNC(js_gfx_Texture_isAlphaAtlas);
+SE_DECLARE_FUNC(js_gfx_Texture_getTarget);
+
+extern se::Object* __jsb_cocos2d_renderer_Texture2D_proto;
+extern se::Class* __jsb_cocos2d_renderer_Texture2D_class;
+
+bool js_register_cocos2d_renderer_Texture2D(se::Object* obj);
+bool register_all_gfx(se::Object* obj);
+SE_DECLARE_FUNC(js_gfx_Texture2D_updateImage);
+SE_DECLARE_FUNC(js_gfx_Texture2D_init);
+SE_DECLARE_FUNC(js_gfx_Texture2D_updateSubImage);
+SE_DECLARE_FUNC(js_gfx_Texture2D_update);
+SE_DECLARE_FUNC(js_gfx_Texture2D_Texture2D);
+
+extern se::Object* __jsb_cocos2d_renderer_Program_proto;
+extern se::Class* __jsb_cocos2d_renderer_Program_class;
+
+bool js_register_cocos2d_renderer_Program(se::Object* obj);
+bool register_all_gfx(se::Object* obj);
+SE_DECLARE_FUNC(js_gfx_Program_getID);
+SE_DECLARE_FUNC(js_gfx_Program_init);
+SE_DECLARE_FUNC(js_gfx_Program_link);
+SE_DECLARE_FUNC(js_gfx_Program_Program);
+
+#endif //#if (USE_GFX_RENDERER > 0) && (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID || CC_TARGET_PLATFORM == CC_PLATFORM_IOS || CC_TARGET_PLATFORM == CC_PLATFORM_MAC || CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)

cocos2d-x/cocos/scripting/js-bindings/auto/jsb_renderer_auto.hpp

@@ -0,0 +1,347 @@
+#pragma once
+#include "base/ccConfig.h"
+#if (USE_GFX_RENDERER > 0) && (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID || CC_TARGET_PLATFORM == CC_PLATFORM_IOS || CC_TARGET_PLATFORM == CC_PLATFORM_MAC || CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)
+
+#include "cocos/scripting/js-bindings/jswrapper/SeApi.h"
+
+extern se::Object* __jsb_cocos2d_renderer_ProgramLib_proto;
+extern se::Class* __jsb_cocos2d_renderer_ProgramLib_class;
+
+bool js_register_cocos2d_renderer_ProgramLib(se::Object* obj);
+bool register_all_renderer(se::Object* obj);
+SE_DECLARE_FUNC(js_renderer_ProgramLib_define);
+SE_DECLARE_FUNC(js_renderer_ProgramLib_ProgramLib);
+
+extern se::Object* __jsb_cocos2d_renderer_EffectBase_proto;
+extern se::Class* __jsb_cocos2d_renderer_EffectBase_class;
+
+bool js_register_cocos2d_renderer_EffectBase(se::Object* obj);
+bool register_all_renderer(se::Object* obj);
+SE_DECLARE_FUNC(js_renderer_EffectBase_getProperty);
+SE_DECLARE_FUNC(js_renderer_EffectBase_setStencilTest);
+SE_DECLARE_FUNC(js_renderer_EffectBase_getDefine);
+SE_DECLARE_FUNC(js_renderer_EffectBase_setCullMode);
+SE_DECLARE_FUNC(js_renderer_EffectBase_setBlend);
+SE_DECLARE_FUNC(js_renderer_EffectBase_setStencil);
+SE_DECLARE_FUNC(js_renderer_EffectBase_getPasses);
+SE_DECLARE_FUNC(js_renderer_EffectBase_setDepth);
+SE_DECLARE_FUNC(js_renderer_EffectBase_define);
+
+extern se::Object* __jsb_cocos2d_renderer_Effect_proto;
+extern se::Class* __jsb_cocos2d_renderer_Effect_class;
+
+bool js_register_cocos2d_renderer_Effect(se::Object* obj);
+bool register_all_renderer(se::Object* obj);
+SE_DECLARE_FUNC(js_renderer_Effect_clear);
+SE_DECLARE_FUNC(js_renderer_Effect_switchTechnique);
+SE_DECLARE_FUNC(js_renderer_Effect_copy);
+SE_DECLARE_FUNC(js_renderer_Effect_Effect);
+
+extern se::Object* __jsb_cocos2d_renderer_EffectVariant_proto;
+extern se::Class* __jsb_cocos2d_renderer_EffectVariant_class;
+
+bool js_register_cocos2d_renderer_EffectVariant(se::Object* obj);
+bool register_all_renderer(se::Object* obj);
+SE_DECLARE_FUNC(js_renderer_EffectVariant_setEffect);
+SE_DECLARE_FUNC(js_renderer_EffectVariant_updateHash);
+SE_DECLARE_FUNC(js_renderer_EffectVariant_copy);
+SE_DECLARE_FUNC(js_renderer_EffectVariant_getEffect);
+SE_DECLARE_FUNC(js_renderer_EffectVariant_EffectVariant);
+
+extern se::Object* __jsb_cocos2d_renderer_AssemblerBase_proto;
+extern se::Class* __jsb_cocos2d_renderer_AssemblerBase_class;
+
+bool js_register_cocos2d_renderer_AssemblerBase(se::Object* obj);
+bool register_all_renderer(se::Object* obj);
+SE_DECLARE_FUNC(js_renderer_AssemblerBase_disableDirty);
+SE_DECLARE_FUNC(js_renderer_AssemblerBase_reset);
+SE_DECLARE_FUNC(js_renderer_AssemblerBase_setUseModel);
+SE_DECLARE_FUNC(js_renderer_AssemblerBase_isDirty);
+SE_DECLARE_FUNC(js_renderer_AssemblerBase_setDirty);
+SE_DECLARE_FUNC(js_renderer_AssemblerBase_AssemblerBase);
+
+extern se::Object* __jsb_cocos2d_renderer_MemPool_proto;
+extern se::Class* __jsb_cocos2d_renderer_MemPool_class;
+
+bool js_register_cocos2d_renderer_MemPool(se::Object* obj);
+bool register_all_renderer(se::Object* obj);
+SE_DECLARE_FUNC(js_renderer_MemPool_removeCommonData);
+SE_DECLARE_FUNC(js_renderer_MemPool_updateCommonData);
+SE_DECLARE_FUNC(js_renderer_MemPool_MemPool);
+
+extern se::Object* __jsb_cocos2d_renderer_NodeProxy_proto;
+extern se::Class* __jsb_cocos2d_renderer_NodeProxy_class;
+
+bool js_register_cocos2d_renderer_NodeProxy(se::Object* obj);
+bool register_all_renderer(se::Object* obj);
+SE_DECLARE_FUNC(js_renderer_NodeProxy_disableVisit);
+SE_DECLARE_FUNC(js_renderer_NodeProxy_switchTraverseToRender);
+SE_DECLARE_FUNC(js_renderer_NodeProxy_notifyUpdateParent);
+SE_DECLARE_FUNC(js_renderer_NodeProxy_destroyImmediately);
+SE_DECLARE_FUNC(js_renderer_NodeProxy_isValid);
+SE_DECLARE_FUNC(js_renderer_NodeProxy_enableVisit);
+SE_DECLARE_FUNC(js_renderer_NodeProxy_getLocalMatrix);
+SE_DECLARE_FUNC(js_renderer_NodeProxy_setName);
+SE_DECLARE_FUNC(js_renderer_NodeProxy_clearAssembler);
+SE_DECLARE_FUNC(js_renderer_NodeProxy_switchTraverseToVisit);
+SE_DECLARE_FUNC(js_renderer_NodeProxy_setAssembler);
+SE_DECLARE_FUNC(js_renderer_NodeProxy_NodeProxy);
+
+extern se::Object* __jsb_cocos2d_renderer_BaseRenderer_proto;
+extern se::Class* __jsb_cocos2d_renderer_BaseRenderer_class;
+
+bool js_register_cocos2d_renderer_BaseRenderer(se::Object* obj);
+bool register_all_renderer(se::Object* obj);
+SE_DECLARE_FUNC(js_renderer_BaseRenderer_getProgramLib);
+SE_DECLARE_FUNC(js_renderer_BaseRenderer_init);
+SE_DECLARE_FUNC(js_renderer_BaseRenderer_BaseRenderer);
+
+extern se::Object* __jsb_cocos2d_renderer_View_proto;
+extern se::Class* __jsb_cocos2d_renderer_View_class;
+
+bool js_register_cocos2d_renderer_View(se::Object* obj);
+bool register_all_renderer(se::Object* obj);
+SE_DECLARE_FUNC(js_renderer_View_View);
+
+extern se::Object* __jsb_cocos2d_renderer_Camera_proto;
+extern se::Class* __jsb_cocos2d_renderer_Camera_class;
+
+bool js_register_cocos2d_renderer_Camera(se::Object* obj);
+bool register_all_renderer(se::Object* obj);
+SE_DECLARE_FUNC(js_renderer_Camera_getDepth);
+SE_DECLARE_FUNC(js_renderer_Camera_setFov);
+SE_DECLARE_FUNC(js_renderer_Camera_getFrameBuffer);
+SE_DECLARE_FUNC(js_renderer_Camera_setStencil);
+SE_DECLARE_FUNC(js_renderer_Camera_setPriority);
+SE_DECLARE_FUNC(js_renderer_Camera_getOrthoHeight);
+SE_DECLARE_FUNC(js_renderer_Camera_setCullingMask);
+SE_DECLARE_FUNC(js_renderer_Camera_getStencil);
+SE_DECLARE_FUNC(js_renderer_Camera_setType);
+SE_DECLARE_FUNC(js_renderer_Camera_getPriority);
+SE_DECLARE_FUNC(js_renderer_Camera_setFar);
+SE_DECLARE_FUNC(js_renderer_Camera_setFrameBuffer);
+SE_DECLARE_FUNC(js_renderer_Camera_setRect);
+SE_DECLARE_FUNC(js_renderer_Camera_setClearFlags);
+SE_DECLARE_FUNC(js_renderer_Camera_getFar);
+SE_DECLARE_FUNC(js_renderer_Camera_getType);
+SE_DECLARE_FUNC(js_renderer_Camera_getCullingMask);
+SE_DECLARE_FUNC(js_renderer_Camera_setNear);
+SE_DECLARE_FUNC(js_renderer_Camera_setStages);
+SE_DECLARE_FUNC(js_renderer_Camera_setOrthoHeight);
+SE_DECLARE_FUNC(js_renderer_Camera_setDepth);
+SE_DECLARE_FUNC(js_renderer_Camera_getStages);
+SE_DECLARE_FUNC(js_renderer_Camera_getFov);
+SE_DECLARE_FUNC(js_renderer_Camera_setColor);
+SE_DECLARE_FUNC(js_renderer_Camera_setWorldMatrix);
+SE_DECLARE_FUNC(js_renderer_Camera_getNear);
+SE_DECLARE_FUNC(js_renderer_Camera_getClearFlags);
+SE_DECLARE_FUNC(js_renderer_Camera_Camera);
+
+extern se::Object* __jsb_cocos2d_renderer_ForwardRenderer_proto;
+extern se::Class* __jsb_cocos2d_renderer_ForwardRenderer_class;
+
+bool js_register_cocos2d_renderer_ForwardRenderer(se::Object* obj);
+bool register_all_renderer(se::Object* obj);
+SE_DECLARE_FUNC(js_renderer_ForwardRenderer_renderCamera);
+SE_DECLARE_FUNC(js_renderer_ForwardRenderer_init);
+SE_DECLARE_FUNC(js_renderer_ForwardRenderer_render);
+SE_DECLARE_FUNC(js_renderer_ForwardRenderer_ForwardRenderer);
+
+extern se::Object* __jsb_cocos2d_renderer_Light_proto;
+extern se::Class* __jsb_cocos2d_renderer_Light_class;
+
+bool js_register_cocos2d_renderer_Light(se::Object* obj);
+bool register_all_renderer(se::Object* obj);
+SE_DECLARE_FUNC(js_renderer_Light_getRange);
+SE_DECLARE_FUNC(js_renderer_Light_setShadowFrustumSize);
+SE_DECLARE_FUNC(js_renderer_Light_setShadowResolution);
+SE_DECLARE_FUNC(js_renderer_Light_getFrustumEdgeFalloff);
+SE_DECLARE_FUNC(js_renderer_Light_setSpotExp);
+SE_DECLARE_FUNC(js_renderer_Light_setShadowType);
+SE_DECLARE_FUNC(js_renderer_Light_setType);
+SE_DECLARE_FUNC(js_renderer_Light_getViewProjMatrix);
+SE_DECLARE_FUNC(js_renderer_Light_getPositionUniform);
+SE_DECLARE_FUNC(js_renderer_Light_getShadowBias);
+SE_DECLARE_FUNC(js_renderer_Light_getShadowDarkness);
+SE_DECLARE_FUNC(js_renderer_Light_getSpotAngle);
+SE_DECLARE_FUNC(js_renderer_Light_getDirectionUniform);
+SE_DECLARE_FUNC(js_renderer_Light_getSpotExp);
+SE_DECLARE_FUNC(js_renderer_Light_setShadowDepthScale);
+SE_DECLARE_FUNC(js_renderer_Light_getViewPorjMatrix);
+SE_DECLARE_FUNC(js_renderer_Light_getSpotAngleUniform);
+SE_DECLARE_FUNC(js_renderer_Light_getType);
+SE_DECLARE_FUNC(js_renderer_Light_getColorUniform);
+SE_DECLARE_FUNC(js_renderer_Light_getIntensity);
+SE_DECLARE_FUNC(js_renderer_Light_getShadowMaxDepth);
+SE_DECLARE_FUNC(js_renderer_Light_getWorldMatrix);
+SE_DECLARE_FUNC(js_renderer_Light_getShadowMap);
+SE_DECLARE_FUNC(js_renderer_Light_getColor);
+SE_DECLARE_FUNC(js_renderer_Light_setIntensity);
+SE_DECLARE_FUNC(js_renderer_Light_getShadowMinDepth);
+SE_DECLARE_FUNC(js_renderer_Light_setShadowMinDepth);
+SE_DECLARE_FUNC(js_renderer_Light_update);
+SE_DECLARE_FUNC(js_renderer_Light_setShadowDarkness);
+SE_DECLARE_FUNC(js_renderer_Light_setWorldMatrix);
+SE_DECLARE_FUNC(js_renderer_Light_setSpotAngle);
+SE_DECLARE_FUNC(js_renderer_Light_setRange);
+SE_DECLARE_FUNC(js_renderer_Light_setColor);
+SE_DECLARE_FUNC(js_renderer_Light_setShadowMaxDepth);
+SE_DECLARE_FUNC(js_renderer_Light_setFrustumEdgeFalloff);
+SE_DECLARE_FUNC(js_renderer_Light_getShadowResolution);
+SE_DECLARE_FUNC(js_renderer_Light_getShadowDepthScale);
+SE_DECLARE_FUNC(js_renderer_Light_getShadowType);
+SE_DECLARE_FUNC(js_renderer_Light_setShadowBias);
+SE_DECLARE_FUNC(js_renderer_Light_Light);
+
+extern se::Object* __jsb_cocos2d_renderer_Scene_proto;
+extern se::Class* __jsb_cocos2d_renderer_Scene_class;
+
+bool js_register_cocos2d_renderer_Scene(se::Object* obj);
+bool register_all_renderer(se::Object* obj);
+SE_DECLARE_FUNC(js_renderer_Scene_getCameraCount);
+SE_DECLARE_FUNC(js_renderer_Scene_removeCamera);
+SE_DECLARE_FUNC(js_renderer_Scene_getLightCount);
+SE_DECLARE_FUNC(js_renderer_Scene_removeView);
+SE_DECLARE_FUNC(js_renderer_Scene_getLights);
+SE_DECLARE_FUNC(js_renderer_Scene_removeLight);
+SE_DECLARE_FUNC(js_renderer_Scene_addCamera);
+SE_DECLARE_FUNC(js_renderer_Scene_getLight);
+SE_DECLARE_FUNC(js_renderer_Scene_addLight);
+SE_DECLARE_FUNC(js_renderer_Scene_getCameras);
+SE_DECLARE_FUNC(js_renderer_Scene_sortCameras);
+SE_DECLARE_FUNC(js_renderer_Scene_setDebugCamera);
+SE_DECLARE_FUNC(js_renderer_Scene_reset);
+SE_DECLARE_FUNC(js_renderer_Scene_getCamera);
+SE_DECLARE_FUNC(js_renderer_Scene_addView);
+SE_DECLARE_FUNC(js_renderer_Scene_Scene);
+
+extern se::Object* __jsb_cocos2d_renderer_NodeMemPool_proto;
+extern se::Class* __jsb_cocos2d_renderer_NodeMemPool_class;
+
+bool js_register_cocos2d_renderer_NodeMemPool(se::Object* obj);
+bool register_all_renderer(se::Object* obj);
+SE_DECLARE_FUNC(js_renderer_NodeMemPool_removeNodeData);
+SE_DECLARE_FUNC(js_renderer_NodeMemPool_updateNodeData);
+SE_DECLARE_FUNC(js_renderer_NodeMemPool_NodeMemPool);
+
+extern se::Object* __jsb_cocos2d_renderer_RenderDataList_proto;
+extern se::Class* __jsb_cocos2d_renderer_RenderDataList_class;
+
+bool js_register_cocos2d_renderer_RenderDataList(se::Object* obj);
+bool register_all_renderer(se::Object* obj);
+SE_DECLARE_FUNC(js_renderer_RenderDataList_updateMesh);
+SE_DECLARE_FUNC(js_renderer_RenderDataList_clear);
+SE_DECLARE_FUNC(js_renderer_RenderDataList_RenderDataList);
+
+extern se::Object* __jsb_cocos2d_renderer_Assembler_proto;
+extern se::Class* __jsb_cocos2d_renderer_Assembler_class;
+
+bool js_register_cocos2d_renderer_Assembler(se::Object* obj);
+bool register_all_renderer(se::Object* obj);
+SE_DECLARE_FUNC(js_renderer_Assembler_setVertexFormat);
+SE_DECLARE_FUNC(js_renderer_Assembler_isIgnoreOpacityFlag);
+SE_DECLARE_FUNC(js_renderer_Assembler_ignoreWorldMatrix);
+SE_DECLARE_FUNC(js_renderer_Assembler_updateVerticesRange);
+SE_DECLARE_FUNC(js_renderer_Assembler_setRenderDataList);
+SE_DECLARE_FUNC(js_renderer_Assembler_updateMeshIndex);
+SE_DECLARE_FUNC(js_renderer_Assembler_updateEffect);
+SE_DECLARE_FUNC(js_renderer_Assembler_updateIndicesRange);
+SE_DECLARE_FUNC(js_renderer_Assembler_ignoreOpacityFlag);
+SE_DECLARE_FUNC(js_renderer_Assembler_Assembler);
+
+extern se::Object* __jsb_cocos2d_renderer_CustomAssembler_proto;
+extern se::Class* __jsb_cocos2d_renderer_CustomAssembler_class;
+
+bool js_register_cocos2d_renderer_CustomAssembler(se::Object* obj);
+bool register_all_renderer(se::Object* obj);
+SE_DECLARE_FUNC(js_renderer_CustomAssembler_clearEffect);
+SE_DECLARE_FUNC(js_renderer_CustomAssembler_updateEffect);
+SE_DECLARE_FUNC(js_renderer_CustomAssembler_updateIABuffer);
+SE_DECLARE_FUNC(js_renderer_CustomAssembler_CustomAssembler);
+
+extern se::Object* __jsb_cocos2d_renderer_RenderFlow_proto;
+extern se::Class* __jsb_cocos2d_renderer_RenderFlow_class;
+
+bool js_register_cocos2d_renderer_RenderFlow(se::Object* obj);
+bool register_all_renderer(se::Object* obj);
+SE_DECLARE_FUNC(js_renderer_RenderFlow_render);
+SE_DECLARE_FUNC(js_renderer_RenderFlow_RenderFlow);
+
+extern se::Object* __jsb_cocos2d_renderer_AssemblerSprite_proto;
+extern se::Class* __jsb_cocos2d_renderer_AssemblerSprite_class;
+
+bool js_register_cocos2d_renderer_AssemblerSprite(se::Object* obj);
+bool register_all_renderer(se::Object* obj);
+SE_DECLARE_FUNC(js_renderer_AssemblerSprite_setLocalData);
+SE_DECLARE_FUNC(js_renderer_AssemblerSprite_AssemblerSprite);
+
+extern se::Object* __jsb_cocos2d_renderer_SimpleSprite2D_proto;
+extern se::Class* __jsb_cocos2d_renderer_SimpleSprite2D_class;
+
+bool js_register_cocos2d_renderer_SimpleSprite2D(se::Object* obj);
+bool register_all_renderer(se::Object* obj);
+SE_DECLARE_FUNC(js_renderer_SimpleSprite2D_SimpleSprite2D);
+
+extern se::Object* __jsb_cocos2d_renderer_MaskAssembler_proto;
+extern se::Class* __jsb_cocos2d_renderer_MaskAssembler_class;
+
+bool js_register_cocos2d_renderer_MaskAssembler(se::Object* obj);
+bool register_all_renderer(se::Object* obj);
+SE_DECLARE_FUNC(js_renderer_MaskAssembler_setMaskInverted);
+SE_DECLARE_FUNC(js_renderer_MaskAssembler_setImageStencil);
+SE_DECLARE_FUNC(js_renderer_MaskAssembler_setClearSubHandle);
+SE_DECLARE_FUNC(js_renderer_MaskAssembler_getMaskInverted);
+SE_DECLARE_FUNC(js_renderer_MaskAssembler_setRenderSubHandle);
+SE_DECLARE_FUNC(js_renderer_MaskAssembler_MaskAssembler);
+
+extern se::Object* __jsb_cocos2d_renderer_TiledMapAssembler_proto;
+extern se::Class* __jsb_cocos2d_renderer_TiledMapAssembler_class;
+
+bool js_register_cocos2d_renderer_TiledMapAssembler(se::Object* obj);
+bool register_all_renderer(se::Object* obj);
+SE_DECLARE_FUNC(js_renderer_TiledMapAssembler_updateNodes);
+SE_DECLARE_FUNC(js_renderer_TiledMapAssembler_clearNodes);
+SE_DECLARE_FUNC(js_renderer_TiledMapAssembler_TiledMapAssembler);
+
+extern se::Object* __jsb_cocos2d_renderer_SlicedSprite2D_proto;
+extern se::Class* __jsb_cocos2d_renderer_SlicedSprite2D_class;
+
+bool js_register_cocos2d_renderer_SlicedSprite2D(se::Object* obj);
+bool register_all_renderer(se::Object* obj);
+SE_DECLARE_FUNC(js_renderer_SlicedSprite2D_SlicedSprite2D);
+
+extern se::Object* __jsb_cocos2d_renderer_MeshAssembler_proto;
+extern se::Class* __jsb_cocos2d_renderer_MeshAssembler_class;
+
+bool js_register_cocos2d_renderer_MeshAssembler(se::Object* obj);
+bool register_all_renderer(se::Object* obj);
+SE_DECLARE_FUNC(js_renderer_MeshAssembler_setNode);
+SE_DECLARE_FUNC(js_renderer_MeshAssembler_updateIAData);
+SE_DECLARE_FUNC(js_renderer_MeshAssembler_MeshAssembler);
+
+extern se::Object* __jsb_cocos2d_renderer_SimpleSprite3D_proto;
+extern se::Class* __jsb_cocos2d_renderer_SimpleSprite3D_class;
+
+bool js_register_cocos2d_renderer_SimpleSprite3D(se::Object* obj);
+bool register_all_renderer(se::Object* obj);
+SE_DECLARE_FUNC(js_renderer_SimpleSprite3D_SimpleSprite3D);
+
+extern se::Object* __jsb_cocos2d_renderer_SlicedSprite3D_proto;
+extern se::Class* __jsb_cocos2d_renderer_SlicedSprite3D_class;
+
+bool js_register_cocos2d_renderer_SlicedSprite3D(se::Object* obj);
+bool register_all_renderer(se::Object* obj);
+SE_DECLARE_FUNC(js_renderer_SlicedSprite3D_SlicedSprite3D);
+
+extern se::Object* __jsb_cocos2d_renderer_Particle3DAssembler_proto;
+extern se::Class* __jsb_cocos2d_renderer_Particle3DAssembler_class;
+
+bool js_register_cocos2d_renderer_Particle3DAssembler(se::Object* obj);
+bool register_all_renderer(se::Object* obj);
+SE_DECLARE_FUNC(js_renderer_Particle3DAssembler_setTrailSpace);
+SE_DECLARE_FUNC(js_renderer_Particle3DAssembler_setTrailVertexFormat);
+SE_DECLARE_FUNC(js_renderer_Particle3DAssembler_setParticleSpace);
+SE_DECLARE_FUNC(js_renderer_Particle3DAssembler_setTrailModuleEnable);
+SE_DECLARE_FUNC(js_renderer_Particle3DAssembler_Particle3DAssembler);
+
+#endif //#if (USE_GFX_RENDERER > 0) && (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID || CC_TARGET_PLATFORM == CC_PLATFORM_IOS || CC_TARGET_PLATFORM == CC_PLATFORM_MAC || CC_TARGET_PLATFORM == CC_PLATFORM_WIN32)

cocos2d-x/cocos/scripting/js-bindings/auto/jsb_video_auto.cpp

@@ -0,0 +1,522 @@
+#include "scripting/js-bindings/auto/jsb_video_auto.hpp"
+#if (USE_VIDEO > 0) && (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID || CC_TARGET_PLATFORM == CC_PLATFORM_IOS) && !defined(CC_TARGET_OS_TVOS)
+#include "scripting/js-bindings/manual/jsb_conversions.hpp"
+#include "scripting/js-bindings/manual/jsb_global.h"
+#include "ui/videoplayer/VideoPlayer.h"
+
+se::Object* __jsb_cocos2d_VideoPlayer_proto = nullptr;
+se::Class* __jsb_cocos2d_VideoPlayer_class = nullptr;
+
+static bool js_video_VideoPlayer_setFullScreenEnabled(se::State& s)
+{
+    cocos2d::VideoPlayer* cobj = (cocos2d::VideoPlayer*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_video_VideoPlayer_setFullScreenEnabled : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        bool arg0;
+        ok &= seval_to_boolean(args[0], &arg0);
+        SE_PRECONDITION2(ok, false, "js_video_VideoPlayer_setFullScreenEnabled : Error processing arguments");
+        cobj->setFullScreenEnabled(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_video_VideoPlayer_setFullScreenEnabled)
+
+static bool js_video_VideoPlayer_getFrameWidth(se::State& s)
+{
+    cocos2d::VideoPlayer* cobj = (cocos2d::VideoPlayer*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_video_VideoPlayer_getFrameWidth : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 0) {
+        int result = cobj->getFrameWidth();
+        ok &= int32_to_seval(result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_video_VideoPlayer_getFrameWidth : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_video_VideoPlayer_getFrameWidth)
+
+static bool js_video_VideoPlayer_duration(se::State& s)
+{
+    cocos2d::VideoPlayer* cobj = (cocos2d::VideoPlayer*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_video_VideoPlayer_duration : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 0) {
+        float result = cobj->duration();
+        ok &= float_to_seval(result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_video_VideoPlayer_duration : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_video_VideoPlayer_duration)
+
+static bool js_video_VideoPlayer_pause(se::State& s)
+{
+    cocos2d::VideoPlayer* cobj = (cocos2d::VideoPlayer*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_video_VideoPlayer_pause : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    if (argc == 0) {
+        cobj->pause();
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_video_VideoPlayer_pause)
+
+static bool js_video_VideoPlayer_getFrame(se::State& s)
+{
+    cocos2d::VideoPlayer* cobj = (cocos2d::VideoPlayer*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_video_VideoPlayer_getFrame : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    if (argc == 0) {
+        cobj->getFrame();
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_video_VideoPlayer_getFrame)
+
+static bool js_video_VideoPlayer_setShowRawFrame(se::State& s)
+{
+    cocos2d::VideoPlayer* cobj = (cocos2d::VideoPlayer*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_video_VideoPlayer_setShowRawFrame : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        bool arg0;
+        ok &= seval_to_boolean(args[0], &arg0);
+        SE_PRECONDITION2(ok, false, "js_video_VideoPlayer_setShowRawFrame : Error processing arguments");
+        cobj->setShowRawFrame(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_video_VideoPlayer_setShowRawFrame)
+
+static bool js_video_VideoPlayer_onPlayEvent(se::State& s)
+{
+    cocos2d::VideoPlayer* cobj = (cocos2d::VideoPlayer*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_video_VideoPlayer_onPlayEvent : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        int arg0 = 0;
+        do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (int)tmp; } while(false);
+        SE_PRECONDITION2(ok, false, "js_video_VideoPlayer_onPlayEvent : Error processing arguments");
+        cobj->onPlayEvent(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_video_VideoPlayer_onPlayEvent)
+
+static bool js_video_VideoPlayer_addEventListener(se::State& s)
+{
+    cocos2d::VideoPlayer* cobj = (cocos2d::VideoPlayer*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_video_VideoPlayer_addEventListener : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 2) {
+        std::string arg0;
+        std::function<void ()> arg1;
+        ok &= seval_to_std_string(args[0], &arg0);
+        do {
+            if (args[1].isObject() && args[1].toObject()->isFunction())
+            {
+                se::Value jsThis(s.thisObject());
+                se::Value jsFunc(args[1]);
+                jsThis.toObject()->attachObject(jsFunc.toObject());
+                auto lambda = [=]() -> void {
+                    se::ScriptEngine::getInstance()->clearException();
+                    se::AutoHandleScope hs;
+        
+                    se::Value rval;
+                    se::Object* thisObj = jsThis.isObject() ? jsThis.toObject() : nullptr;
+                    se::Object* funcObj = jsFunc.toObject();
+                    bool succeed = funcObj->call(se::EmptyValueArray, thisObj, &rval);
+                    if (!succeed) {
+                        se::ScriptEngine::getInstance()->clearException();
+                    }
+                };
+                arg1 = lambda;
+            }
+            else
+            {
+                arg1 = nullptr;
+            }
+        } while(false)
+        ;
+        SE_PRECONDITION2(ok, false, "js_video_VideoPlayer_addEventListener : Error processing arguments");
+        cobj->addEventListener(arg0, arg1);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
+    return false;
+}
+SE_BIND_FUNC(js_video_VideoPlayer_addEventListener)
+
+static bool js_video_VideoPlayer_seekTo(se::State& s)
+{
+    cocos2d::VideoPlayer* cobj = (cocos2d::VideoPlayer*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_video_VideoPlayer_seekTo : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        float arg0 = 0;
+        ok &= seval_to_float(args[0], &arg0);
+        SE_PRECONDITION2(ok, false, "js_video_VideoPlayer_seekTo : Error processing arguments");
+        cobj->seekTo(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_video_VideoPlayer_seekTo)
+
+static bool js_video_VideoPlayer_play(se::State& s)
+{
+    cocos2d::VideoPlayer* cobj = (cocos2d::VideoPlayer*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_video_VideoPlayer_play : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    if (argc == 0) {
+        cobj->play();
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_video_VideoPlayer_play)
+
+static bool js_video_VideoPlayer_getFrameHeight(se::State& s)
+{
+    cocos2d::VideoPlayer* cobj = (cocos2d::VideoPlayer*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_video_VideoPlayer_getFrameHeight : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 0) {
+        int result = cobj->getFrameHeight();
+        ok &= int32_to_seval(result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_video_VideoPlayer_getFrameHeight : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_video_VideoPlayer_getFrameHeight)
+
+static bool js_video_VideoPlayer_stop(se::State& s)
+{
+    cocos2d::VideoPlayer* cobj = (cocos2d::VideoPlayer*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_video_VideoPlayer_stop : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    if (argc == 0) {
+        cobj->stop();
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_video_VideoPlayer_stop)
+
+static bool js_video_VideoPlayer_setURL(se::State& s)
+{
+    cocos2d::VideoPlayer* cobj = (cocos2d::VideoPlayer*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_video_VideoPlayer_setURL : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        std::string arg0;
+        ok &= seval_to_std_string(args[0], &arg0);
+        SE_PRECONDITION2(ok, false, "js_video_VideoPlayer_setURL : Error processing arguments");
+        cobj->setURL(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_video_VideoPlayer_setURL)
+
+static bool js_video_VideoPlayer_update(se::State& s)
+{
+    cocos2d::VideoPlayer* cobj = (cocos2d::VideoPlayer*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_video_VideoPlayer_update : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    if (argc == 0) {
+        cobj->update();
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_video_VideoPlayer_update)
+
+static bool js_video_VideoPlayer_pushFrameDataToTexture2D(se::State& s)
+{
+    cocos2d::VideoPlayer* cobj = (cocos2d::VideoPlayer*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_video_VideoPlayer_pushFrameDataToTexture2D : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        cocos2d::renderer::Texture* arg0 = nullptr;
+        ok &= seval_to_native_ptr(args[0], &arg0);
+        SE_PRECONDITION2(ok, false, "js_video_VideoPlayer_pushFrameDataToTexture2D : Error processing arguments");
+        cobj->pushFrameDataToTexture2D(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_video_VideoPlayer_pushFrameDataToTexture2D)
+
+static bool js_video_VideoPlayer_isKeepAspectRatioEnabled(se::State& s)
+{
+    cocos2d::VideoPlayer* cobj = (cocos2d::VideoPlayer*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_video_VideoPlayer_isKeepAspectRatioEnabled : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 0) {
+        bool result = cobj->isKeepAspectRatioEnabled();
+        ok &= boolean_to_seval(result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_video_VideoPlayer_isKeepAspectRatioEnabled : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_video_VideoPlayer_isKeepAspectRatioEnabled)
+
+static bool js_video_VideoPlayer_getFrameChannel(se::State& s)
+{
+    cocos2d::VideoPlayer* cobj = (cocos2d::VideoPlayer*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_video_VideoPlayer_getFrameChannel : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 0) {
+        int result = cobj->getFrameChannel();
+        ok &= int32_to_seval(result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_video_VideoPlayer_getFrameChannel : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_video_VideoPlayer_getFrameChannel)
+
+static bool js_video_VideoPlayer_getVideoTexDataSize(se::State& s)
+{
+    cocos2d::VideoPlayer* cobj = (cocos2d::VideoPlayer*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_video_VideoPlayer_getVideoTexDataSize : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 0) {
+        int result = cobj->getVideoTexDataSize();
+        ok &= int32_to_seval(result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_video_VideoPlayer_getVideoTexDataSize : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_video_VideoPlayer_getVideoTexDataSize)
+
+static bool js_video_VideoPlayer_setKeepAspectRatioEnabled(se::State& s)
+{
+    cocos2d::VideoPlayer* cobj = (cocos2d::VideoPlayer*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_video_VideoPlayer_setKeepAspectRatioEnabled : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        bool arg0;
+        ok &= seval_to_boolean(args[0], &arg0);
+        SE_PRECONDITION2(ok, false, "js_video_VideoPlayer_setKeepAspectRatioEnabled : Error processing arguments");
+        cobj->setKeepAspectRatioEnabled(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_video_VideoPlayer_setKeepAspectRatioEnabled)
+
+static bool js_video_VideoPlayer_currentTime(se::State& s)
+{
+    cocos2d::VideoPlayer* cobj = (cocos2d::VideoPlayer*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_video_VideoPlayer_currentTime : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 0) {
+        float result = cobj->currentTime();
+        ok &= float_to_seval(result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_video_VideoPlayer_currentTime : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_video_VideoPlayer_currentTime)
+
+static bool js_video_VideoPlayer_setFrame(se::State& s)
+{
+    cocos2d::VideoPlayer* cobj = (cocos2d::VideoPlayer*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_video_VideoPlayer_setFrame : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 4) {
+        float arg0 = 0;
+        float arg1 = 0;
+        float arg2 = 0;
+        float arg3 = 0;
+        ok &= seval_to_float(args[0], &arg0);
+        ok &= seval_to_float(args[1], &arg1);
+        ok &= seval_to_float(args[2], &arg2);
+        ok &= seval_to_float(args[3], &arg3);
+        SE_PRECONDITION2(ok, false, "js_video_VideoPlayer_setFrame : Error processing arguments");
+        cobj->setFrame(arg0, arg1, arg2, arg3);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4);
+    return false;
+}
+SE_BIND_FUNC(js_video_VideoPlayer_setFrame)
+
+static bool js_video_VideoPlayer_setVisible(se::State& s)
+{
+    cocos2d::VideoPlayer* cobj = (cocos2d::VideoPlayer*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_video_VideoPlayer_setVisible : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        bool arg0;
+        ok &= seval_to_boolean(args[0], &arg0);
+        SE_PRECONDITION2(ok, false, "js_video_VideoPlayer_setVisible : Error processing arguments");
+        cobj->setVisible(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_video_VideoPlayer_setVisible)
+
+SE_DECLARE_FINALIZE_FUNC(js_cocos2d_VideoPlayer_finalize)
+
+static bool js_video_VideoPlayer_constructor(se::State& s)
+{
+    cocos2d::VideoPlayer* cobj = new (std::nothrow) cocos2d::VideoPlayer();
+    s.thisObject()->setPrivateData(cobj);
+    return true;
+}
+SE_BIND_CTOR(js_video_VideoPlayer_constructor, __jsb_cocos2d_VideoPlayer_class, js_cocos2d_VideoPlayer_finalize)
+
+
+
+
+static bool js_cocos2d_VideoPlayer_finalize(se::State& s)
+{
+    // destructor is skipped
+    return true;
+}
+SE_BIND_FINALIZE_FUNC(js_cocos2d_VideoPlayer_finalize)
+
+static bool js_cocos2d_VideoPlayer_destroy(se::State& s)
+{
+    CCLOGINFO("jsbindings: destory JS object %p (cocos2d::VideoPlayer)", s.nativeThisObject());
+    cocos2d::VideoPlayer* cobj = (cocos2d::VideoPlayer*)s.nativeThisObject();
+    cobj->release();
+    auto objIter = se::NativePtrToObjectMap::find(s.nativeThisObject());
+    if(objIter != se::NativePtrToObjectMap::end())
+    {
+        objIter->second->clearPrivateData(true);
+    }
+    return true;
+}
+SE_BIND_FUNC(js_cocos2d_VideoPlayer_destroy)
+
+bool js_register_video_VideoPlayer(se::Object* obj)
+{
+    auto cls = se::Class::create("VideoPlayer", obj, nullptr, _SE(js_video_VideoPlayer_constructor));
+
+    cls->defineFunction("setFullScreenEnabled", _SE(js_video_VideoPlayer_setFullScreenEnabled));
+    cls->defineFunction("getFrameWidth", _SE(js_video_VideoPlayer_getFrameWidth));
+    cls->defineFunction("duration", _SE(js_video_VideoPlayer_duration));
+    cls->defineFunction("pause", _SE(js_video_VideoPlayer_pause));
+    cls->defineFunction("getFrame", _SE(js_video_VideoPlayer_getFrame));
+    cls->defineFunction("setShowRawFrame", _SE(js_video_VideoPlayer_setShowRawFrame));
+    cls->defineFunction("onPlayEvent", _SE(js_video_VideoPlayer_onPlayEvent));
+    cls->defineFunction("addEventListener", _SE(js_video_VideoPlayer_addEventListener));
+    cls->defineFunction("seekTo", _SE(js_video_VideoPlayer_seekTo));
+    cls->defineFunction("play", _SE(js_video_VideoPlayer_play));
+    cls->defineFunction("getFrameHeight", _SE(js_video_VideoPlayer_getFrameHeight));
+    cls->defineFunction("stop", _SE(js_video_VideoPlayer_stop));
+    cls->defineFunction("setURL", _SE(js_video_VideoPlayer_setURL));
+    cls->defineFunction("update", _SE(js_video_VideoPlayer_update));
+    cls->defineFunction("pushFrameDataToTexture2D", _SE(js_video_VideoPlayer_pushFrameDataToTexture2D));
+    cls->defineFunction("isKeepAspectRatioEnabled", _SE(js_video_VideoPlayer_isKeepAspectRatioEnabled));
+    cls->defineFunction("getFrameChannel", _SE(js_video_VideoPlayer_getFrameChannel));
+    cls->defineFunction("getVideoTexDataSize", _SE(js_video_VideoPlayer_getVideoTexDataSize));
+    cls->defineFunction("setKeepAspectRatioEnabled", _SE(js_video_VideoPlayer_setKeepAspectRatioEnabled));
+    cls->defineFunction("currentTime", _SE(js_video_VideoPlayer_currentTime));
+    cls->defineFunction("setFrame", _SE(js_video_VideoPlayer_setFrame));
+    cls->defineFunction("setVisible", _SE(js_video_VideoPlayer_setVisible));
+    cls->defineFunction("destroy", _SE(js_cocos2d_VideoPlayer_destroy));
+    cls->defineFinalizeFunction(_SE(js_cocos2d_VideoPlayer_finalize));
+    cls->install();
+    JSBClassType::registerClass<cocos2d::VideoPlayer>(cls);
+
+    __jsb_cocos2d_VideoPlayer_proto = cls->getProto();
+    __jsb_cocos2d_VideoPlayer_class = cls;
+
+    se::ScriptEngine::getInstance()->clearException();
+    return true;
+}
+
+bool register_all_video(se::Object* obj)
+{
+    // Get the ns
+    se::Value nsVal;
+    if (!obj->getProperty("jsb", &nsVal))
+    {
+        se::HandleObject jsobj(se::Object::createPlainObject());
+        nsVal.setObject(jsobj);
+        obj->setProperty("jsb", nsVal);
+    }
+    se::Object* ns = nsVal.toObject();
+
+    js_register_video_VideoPlayer(ns);
+    return true;
+}
+
+#endif //#if (USE_VIDEO > 0) && (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID || CC_TARGET_PLATFORM == CC_PLATFORM_IOS) && !defined(CC_TARGET_OS_TVOS)

cocos2d-x/cocos/scripting/js-bindings/auto/jsb_video_auto.hpp

@@ -0,0 +1,36 @@
+#pragma once
+#include "base/ccConfig.h"
+#if (USE_VIDEO > 0) && (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID || CC_TARGET_PLATFORM == CC_PLATFORM_IOS) && !defined(CC_TARGET_OS_TVOS)
+
+#include "cocos/scripting/js-bindings/jswrapper/SeApi.h"
+
+extern se::Object* __jsb_cocos2d_VideoPlayer_proto;
+extern se::Class* __jsb_cocos2d_VideoPlayer_class;
+
+bool js_register_cocos2d_VideoPlayer(se::Object* obj);
+bool register_all_video(se::Object* obj);
+SE_DECLARE_FUNC(js_video_VideoPlayer_setFullScreenEnabled);
+SE_DECLARE_FUNC(js_video_VideoPlayer_getFrameWidth);
+SE_DECLARE_FUNC(js_video_VideoPlayer_duration);
+SE_DECLARE_FUNC(js_video_VideoPlayer_pause);
+SE_DECLARE_FUNC(js_video_VideoPlayer_getFrame);
+SE_DECLARE_FUNC(js_video_VideoPlayer_setShowRawFrame);
+SE_DECLARE_FUNC(js_video_VideoPlayer_onPlayEvent);
+SE_DECLARE_FUNC(js_video_VideoPlayer_addEventListener);
+SE_DECLARE_FUNC(js_video_VideoPlayer_seekTo);
+SE_DECLARE_FUNC(js_video_VideoPlayer_play);
+SE_DECLARE_FUNC(js_video_VideoPlayer_getFrameHeight);
+SE_DECLARE_FUNC(js_video_VideoPlayer_stop);
+SE_DECLARE_FUNC(js_video_VideoPlayer_setURL);
+SE_DECLARE_FUNC(js_video_VideoPlayer_update);
+SE_DECLARE_FUNC(js_video_VideoPlayer_pushFrameDataToTexture2D);
+SE_DECLARE_FUNC(js_video_VideoPlayer_isKeepAspectRatioEnabled);
+SE_DECLARE_FUNC(js_video_VideoPlayer_getFrameChannel);
+SE_DECLARE_FUNC(js_video_VideoPlayer_getVideoTexDataSize);
+SE_DECLARE_FUNC(js_video_VideoPlayer_setKeepAspectRatioEnabled);
+SE_DECLARE_FUNC(js_video_VideoPlayer_currentTime);
+SE_DECLARE_FUNC(js_video_VideoPlayer_setFrame);
+SE_DECLARE_FUNC(js_video_VideoPlayer_setVisible);
+SE_DECLARE_FUNC(js_video_VideoPlayer_VideoPlayer);
+
+#endif //#if (USE_VIDEO > 0) && (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID || CC_TARGET_PLATFORM == CC_PLATFORM_IOS) && !defined(CC_TARGET_OS_TVOS)

cocos2d-x/cocos/scripting/js-bindings/auto/jsb_webview_auto.cpp

@@ -0,0 +1,718 @@
+#include "scripting/js-bindings/auto/jsb_webview_auto.hpp"
+#if (USE_WEB_VIEW > 0) && (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID || CC_TARGET_PLATFORM == CC_PLATFORM_IOS) && !defined(CC_TARGET_OS_TVOS)
+#include "scripting/js-bindings/manual/jsb_conversions.hpp"
+#include "scripting/js-bindings/manual/jsb_global.h"
+#include "ui/webview/WebView.h"
+
+se::Object* __jsb_cocos2d_WebView_proto = nullptr;
+se::Class* __jsb_cocos2d_WebView_class = nullptr;
+
+static bool js_webview_WebView_setOnShouldStartLoading(se::State& s)
+{
+    cocos2d::WebView* cobj = (cocos2d::WebView*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_webview_WebView_setOnShouldStartLoading : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        std::function<bool (cocos2d::WebView *, const std::string&)> arg0;
+        do {
+            if (args[0].isObject() && args[0].toObject()->isFunction())
+            {
+                se::Value jsThis(s.thisObject());
+                se::Value jsFunc(args[0]);
+                jsThis.toObject()->attachObject(jsFunc.toObject());
+                auto lambda = [=](cocos2d::WebView* larg0, const std::string& larg1) -> bool {
+                    se::ScriptEngine::getInstance()->clearException();
+                    se::AutoHandleScope hs;
+        
+                    CC_UNUSED bool ok = true;
+                    se::ValueArray args;
+                    args.resize(2);
+                    ok &= native_ptr_to_seval<cocos2d::WebView>((cocos2d::WebView*)larg0, &args[0]);
+                    ok &= std_string_to_seval(larg1, &args[1]);
+                    se::Value rval;
+                    se::Object* thisObj = jsThis.isObject() ? jsThis.toObject() : nullptr;
+                    se::Object* funcObj = jsFunc.toObject();
+                    bool succeed = funcObj->call(args, thisObj, &rval);
+                    if (!succeed) {
+                        se::ScriptEngine::getInstance()->clearException();
+                    }
+                    bool result;
+                    ok &= seval_to_boolean(rval, &result);
+                    SE_PRECONDITION2(ok, result, "lambda function : Error processing return value with type bool");
+                    return result;
+                };
+                arg0 = lambda;
+            }
+            else
+            {
+                arg0 = nullptr;
+            }
+        } while(false)
+        ;
+        SE_PRECONDITION2(ok, false, "js_webview_WebView_setOnShouldStartLoading : Error processing arguments");
+        cobj->setOnShouldStartLoading(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_webview_WebView_setOnShouldStartLoading)
+
+static bool js_webview_WebView_setOnDidFailLoading(se::State& s)
+{
+    cocos2d::WebView* cobj = (cocos2d::WebView*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_webview_WebView_setOnDidFailLoading : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        std::function<void (cocos2d::WebView *, const std::string&)> arg0;
+        do {
+            if (args[0].isObject() && args[0].toObject()->isFunction())
+            {
+                se::Value jsThis(s.thisObject());
+                se::Value jsFunc(args[0]);
+                jsThis.toObject()->attachObject(jsFunc.toObject());
+                auto lambda = [=](cocos2d::WebView* larg0, const std::string& larg1) -> void {
+                    se::ScriptEngine::getInstance()->clearException();
+                    se::AutoHandleScope hs;
+        
+                    CC_UNUSED bool ok = true;
+                    se::ValueArray args;
+                    args.resize(2);
+                    ok &= native_ptr_to_seval<cocos2d::WebView>((cocos2d::WebView*)larg0, &args[0]);
+                    ok &= std_string_to_seval(larg1, &args[1]);
+                    se::Value rval;
+                    se::Object* thisObj = jsThis.isObject() ? jsThis.toObject() : nullptr;
+                    se::Object* funcObj = jsFunc.toObject();
+                    bool succeed = funcObj->call(args, thisObj, &rval);
+                    if (!succeed) {
+                        se::ScriptEngine::getInstance()->clearException();
+                    }
+                };
+                arg0 = lambda;
+            }
+            else
+            {
+                arg0 = nullptr;
+            }
+        } while(false)
+        ;
+        SE_PRECONDITION2(ok, false, "js_webview_WebView_setOnDidFailLoading : Error processing arguments");
+        cobj->setOnDidFailLoading(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_webview_WebView_setOnDidFailLoading)
+
+static bool js_webview_WebView_canGoBack(se::State& s)
+{
+    cocos2d::WebView* cobj = (cocos2d::WebView*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_webview_WebView_canGoBack : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 0) {
+        bool result = cobj->canGoBack();
+        ok &= boolean_to_seval(result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_webview_WebView_canGoBack : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_webview_WebView_canGoBack)
+
+static bool js_webview_WebView_loadHTMLString(se::State& s)
+{
+    cocos2d::WebView* cobj = (cocos2d::WebView*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_webview_WebView_loadHTMLString : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        std::string arg0;
+        ok &= seval_to_std_string(args[0], &arg0);
+        SE_PRECONDITION2(ok, false, "js_webview_WebView_loadHTMLString : Error processing arguments");
+        cobj->loadHTMLString(arg0);
+        return true;
+    }
+    if (argc == 2) {
+        std::string arg0;
+        std::string arg1;
+        ok &= seval_to_std_string(args[0], &arg0);
+        ok &= seval_to_std_string(args[1], &arg1);
+        SE_PRECONDITION2(ok, false, "js_webview_WebView_loadHTMLString : Error processing arguments");
+        cobj->loadHTMLString(arg0, arg1);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
+    return false;
+}
+SE_BIND_FUNC(js_webview_WebView_loadHTMLString)
+
+static bool js_webview_WebView_goForward(se::State& s)
+{
+    cocos2d::WebView* cobj = (cocos2d::WebView*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_webview_WebView_goForward : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    if (argc == 0) {
+        cobj->goForward();
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_webview_WebView_goForward)
+
+static bool js_webview_WebView_goBack(se::State& s)
+{
+    cocos2d::WebView* cobj = (cocos2d::WebView*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_webview_WebView_goBack : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    if (argc == 0) {
+        cobj->goBack();
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_webview_WebView_goBack)
+
+static bool js_webview_WebView_setScalesPageToFit(se::State& s)
+{
+    cocos2d::WebView* cobj = (cocos2d::WebView*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_webview_WebView_setScalesPageToFit : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        bool arg0;
+        ok &= seval_to_boolean(args[0], &arg0);
+        SE_PRECONDITION2(ok, false, "js_webview_WebView_setScalesPageToFit : Error processing arguments");
+        cobj->setScalesPageToFit(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_webview_WebView_setScalesPageToFit)
+
+static bool js_webview_WebView_getOnDidFailLoading(se::State& s)
+{
+    cocos2d::WebView* cobj = (cocos2d::WebView*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_webview_WebView_getOnDidFailLoading : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 0) {
+        cocos2d::WebView::ccWebViewCallback result = cobj->getOnDidFailLoading();
+        #pragma warning NO CONVERSION FROM NATIVE FOR std::function;
+        SE_PRECONDITION2(ok, false, "js_webview_WebView_getOnDidFailLoading : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_webview_WebView_getOnDidFailLoading)
+
+static bool js_webview_WebView_loadFile(se::State& s)
+{
+    cocos2d::WebView* cobj = (cocos2d::WebView*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_webview_WebView_loadFile : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        std::string arg0;
+        ok &= seval_to_std_string(args[0], &arg0);
+        SE_PRECONDITION2(ok, false, "js_webview_WebView_loadFile : Error processing arguments");
+        cobj->loadFile(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_webview_WebView_loadFile)
+
+static bool js_webview_WebView_loadURL(se::State& s)
+{
+    cocos2d::WebView* cobj = (cocos2d::WebView*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_webview_WebView_loadURL : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        std::string arg0;
+        ok &= seval_to_std_string(args[0], &arg0);
+        SE_PRECONDITION2(ok, false, "js_webview_WebView_loadURL : Error processing arguments");
+        cobj->loadURL(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_webview_WebView_loadURL)
+
+static bool js_webview_WebView_setBounces(se::State& s)
+{
+    cocos2d::WebView* cobj = (cocos2d::WebView*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_webview_WebView_setBounces : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        bool arg0;
+        ok &= seval_to_boolean(args[0], &arg0);
+        SE_PRECONDITION2(ok, false, "js_webview_WebView_setBounces : Error processing arguments");
+        cobj->setBounces(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_webview_WebView_setBounces)
+
+static bool js_webview_WebView_evaluateJS(se::State& s)
+{
+    cocos2d::WebView* cobj = (cocos2d::WebView*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_webview_WebView_evaluateJS : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        std::string arg0;
+        ok &= seval_to_std_string(args[0], &arg0);
+        SE_PRECONDITION2(ok, false, "js_webview_WebView_evaluateJS : Error processing arguments");
+        cobj->evaluateJS(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_webview_WebView_evaluateJS)
+
+static bool js_webview_WebView_setOnJSCallback(se::State& s)
+{
+    cocos2d::WebView* cobj = (cocos2d::WebView*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_webview_WebView_setOnJSCallback : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        std::function<void (cocos2d::WebView *, const std::string&)> arg0;
+        do {
+            if (args[0].isObject() && args[0].toObject()->isFunction())
+            {
+                se::Value jsThis(s.thisObject());
+                se::Value jsFunc(args[0]);
+                jsThis.toObject()->attachObject(jsFunc.toObject());
+                auto lambda = [=](cocos2d::WebView* larg0, const std::string& larg1) -> void {
+                    se::ScriptEngine::getInstance()->clearException();
+                    se::AutoHandleScope hs;
+        
+                    CC_UNUSED bool ok = true;
+                    se::ValueArray args;
+                    args.resize(2);
+                    ok &= native_ptr_to_seval<cocos2d::WebView>((cocos2d::WebView*)larg0, &args[0]);
+                    ok &= std_string_to_seval(larg1, &args[1]);
+                    se::Value rval;
+                    se::Object* thisObj = jsThis.isObject() ? jsThis.toObject() : nullptr;
+                    se::Object* funcObj = jsFunc.toObject();
+                    bool succeed = funcObj->call(args, thisObj, &rval);
+                    if (!succeed) {
+                        se::ScriptEngine::getInstance()->clearException();
+                    }
+                };
+                arg0 = lambda;
+            }
+            else
+            {
+                arg0 = nullptr;
+            }
+        } while(false)
+        ;
+        SE_PRECONDITION2(ok, false, "js_webview_WebView_setOnJSCallback : Error processing arguments");
+        cobj->setOnJSCallback(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_webview_WebView_setOnJSCallback)
+
+static bool js_webview_WebView_setBackgroundTransparent(se::State& s)
+{
+    cocos2d::WebView* cobj = (cocos2d::WebView*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_webview_WebView_setBackgroundTransparent : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        bool arg0;
+        ok &= seval_to_boolean(args[0], &arg0);
+        SE_PRECONDITION2(ok, false, "js_webview_WebView_setBackgroundTransparent : Error processing arguments");
+        cobj->setBackgroundTransparent(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_webview_WebView_setBackgroundTransparent)
+
+static bool js_webview_WebView_getOnJSCallback(se::State& s)
+{
+    cocos2d::WebView* cobj = (cocos2d::WebView*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_webview_WebView_getOnJSCallback : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 0) {
+        cocos2d::WebView::ccWebViewCallback result = cobj->getOnJSCallback();
+        #pragma warning NO CONVERSION FROM NATIVE FOR std::function;
+        SE_PRECONDITION2(ok, false, "js_webview_WebView_getOnJSCallback : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_webview_WebView_getOnJSCallback)
+
+static bool js_webview_WebView_canGoForward(se::State& s)
+{
+    cocos2d::WebView* cobj = (cocos2d::WebView*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_webview_WebView_canGoForward : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 0) {
+        bool result = cobj->canGoForward();
+        ok &= boolean_to_seval(result, &s.rval());
+        SE_PRECONDITION2(ok, false, "js_webview_WebView_canGoForward : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_webview_WebView_canGoForward)
+
+static bool js_webview_WebView_getOnShouldStartLoading(se::State& s)
+{
+    cocos2d::WebView* cobj = (cocos2d::WebView*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_webview_WebView_getOnShouldStartLoading : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 0) {
+        std::function<bool (cocos2d::WebView *, const std::string&)> result = cobj->getOnShouldStartLoading();
+        #pragma warning NO CONVERSION FROM NATIVE FOR std::function;
+        SE_PRECONDITION2(ok, false, "js_webview_WebView_getOnShouldStartLoading : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_webview_WebView_getOnShouldStartLoading)
+
+static bool js_webview_WebView_stopLoading(se::State& s)
+{
+    cocos2d::WebView* cobj = (cocos2d::WebView*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_webview_WebView_stopLoading : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    if (argc == 0) {
+        cobj->stopLoading();
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_webview_WebView_stopLoading)
+
+static bool js_webview_WebView_setFrame(se::State& s)
+{
+    cocos2d::WebView* cobj = (cocos2d::WebView*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_webview_WebView_setFrame : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 4) {
+        float arg0 = 0;
+        float arg1 = 0;
+        float arg2 = 0;
+        float arg3 = 0;
+        ok &= seval_to_float(args[0], &arg0);
+        ok &= seval_to_float(args[1], &arg1);
+        ok &= seval_to_float(args[2], &arg2);
+        ok &= seval_to_float(args[3], &arg3);
+        SE_PRECONDITION2(ok, false, "js_webview_WebView_setFrame : Error processing arguments");
+        cobj->setFrame(arg0, arg1, arg2, arg3);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4);
+    return false;
+}
+SE_BIND_FUNC(js_webview_WebView_setFrame)
+
+static bool js_webview_WebView_setVisible(se::State& s)
+{
+    cocos2d::WebView* cobj = (cocos2d::WebView*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_webview_WebView_setVisible : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        bool arg0;
+        ok &= seval_to_boolean(args[0], &arg0);
+        SE_PRECONDITION2(ok, false, "js_webview_WebView_setVisible : Error processing arguments");
+        cobj->setVisible(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_webview_WebView_setVisible)
+
+static bool js_webview_WebView_reload(se::State& s)
+{
+    cocos2d::WebView* cobj = (cocos2d::WebView*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_webview_WebView_reload : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    if (argc == 0) {
+        cobj->reload();
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_webview_WebView_reload)
+
+static bool js_webview_WebView_loadData(se::State& s)
+{
+    cocos2d::WebView* cobj = (cocos2d::WebView*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_webview_WebView_loadData : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 4) {
+        cocos2d::Data arg0;
+        std::string arg1;
+        std::string arg2;
+        std::string arg3;
+        ok &= seval_to_Data(args[0], &arg0);
+        ok &= seval_to_std_string(args[1], &arg1);
+        ok &= seval_to_std_string(args[2], &arg2);
+        ok &= seval_to_std_string(args[3], &arg3);
+        SE_PRECONDITION2(ok, false, "js_webview_WebView_loadData : Error processing arguments");
+        cobj->loadData(arg0, arg1, arg2, arg3);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4);
+    return false;
+}
+SE_BIND_FUNC(js_webview_WebView_loadData)
+
+static bool js_webview_WebView_setJavascriptInterfaceScheme(se::State& s)
+{
+    cocos2d::WebView* cobj = (cocos2d::WebView*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_webview_WebView_setJavascriptInterfaceScheme : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        std::string arg0;
+        ok &= seval_to_std_string(args[0], &arg0);
+        SE_PRECONDITION2(ok, false, "js_webview_WebView_setJavascriptInterfaceScheme : Error processing arguments");
+        cobj->setJavascriptInterfaceScheme(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_webview_WebView_setJavascriptInterfaceScheme)
+
+static bool js_webview_WebView_setOnDidFinishLoading(se::State& s)
+{
+    cocos2d::WebView* cobj = (cocos2d::WebView*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_webview_WebView_setOnDidFinishLoading : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 1) {
+        std::function<void (cocos2d::WebView *, const std::string&)> arg0;
+        do {
+            if (args[0].isObject() && args[0].toObject()->isFunction())
+            {
+                se::Value jsThis(s.thisObject());
+                se::Value jsFunc(args[0]);
+                jsThis.toObject()->attachObject(jsFunc.toObject());
+                auto lambda = [=](cocos2d::WebView* larg0, const std::string& larg1) -> void {
+                    se::ScriptEngine::getInstance()->clearException();
+                    se::AutoHandleScope hs;
+        
+                    CC_UNUSED bool ok = true;
+                    se::ValueArray args;
+                    args.resize(2);
+                    ok &= native_ptr_to_seval<cocos2d::WebView>((cocos2d::WebView*)larg0, &args[0]);
+                    ok &= std_string_to_seval(larg1, &args[1]);
+                    se::Value rval;
+                    se::Object* thisObj = jsThis.isObject() ? jsThis.toObject() : nullptr;
+                    se::Object* funcObj = jsFunc.toObject();
+                    bool succeed = funcObj->call(args, thisObj, &rval);
+                    if (!succeed) {
+                        se::ScriptEngine::getInstance()->clearException();
+                    }
+                };
+                arg0 = lambda;
+            }
+            else
+            {
+                arg0 = nullptr;
+            }
+        } while(false)
+        ;
+        SE_PRECONDITION2(ok, false, "js_webview_WebView_setOnDidFinishLoading : Error processing arguments");
+        cobj->setOnDidFinishLoading(arg0);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
+    return false;
+}
+SE_BIND_FUNC(js_webview_WebView_setOnDidFinishLoading)
+
+static bool js_webview_WebView_getOnDidFinishLoading(se::State& s)
+{
+    cocos2d::WebView* cobj = (cocos2d::WebView*)s.nativeThisObject();
+    SE_PRECONDITION2(cobj, false, "js_webview_WebView_getOnDidFinishLoading : Invalid Native Object");
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 0) {
+        cocos2d::WebView::ccWebViewCallback result = cobj->getOnDidFinishLoading();
+        #pragma warning NO CONVERSION FROM NATIVE FOR std::function;
+        SE_PRECONDITION2(ok, false, "js_webview_WebView_getOnDidFinishLoading : Error processing arguments");
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_webview_WebView_getOnDidFinishLoading)
+
+static bool js_webview_WebView_create(se::State& s)
+{
+    const auto& args = s.args();
+    size_t argc = args.size();
+    CC_UNUSED bool ok = true;
+    if (argc == 0) {
+        auto result = cocos2d::WebView::create();
+        result->retain();
+        auto obj = se::Object::createObjectWithClass(__jsb_cocos2d_WebView_class);
+        obj->setPrivateData(result);
+        s.rval().setObject(obj);
+        return true;
+    }
+    SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
+    return false;
+}
+SE_BIND_FUNC(js_webview_WebView_create)
+
+SE_DECLARE_FINALIZE_FUNC(js_cocos2d_WebView_finalize)
+
+static bool js_webview_WebView_constructor(se::State& s)
+{
+    cocos2d::WebView* cobj = new (std::nothrow) cocos2d::WebView();
+    s.thisObject()->setPrivateData(cobj);
+    return true;
+}
+SE_BIND_CTOR(js_webview_WebView_constructor, __jsb_cocos2d_WebView_class, js_cocos2d_WebView_finalize)
+
+
+
+
+static bool js_cocos2d_WebView_finalize(se::State& s)
+{
+    // destructor is skipped
+    return true;
+}
+SE_BIND_FINALIZE_FUNC(js_cocos2d_WebView_finalize)
+
+static bool js_cocos2d_WebView_destroy(se::State& s)
+{
+    CCLOGINFO("jsbindings: destory JS object %p (cocos2d::WebView)", s.nativeThisObject());
+    cocos2d::WebView* cobj = (cocos2d::WebView*)s.nativeThisObject();
+    cobj->release();
+    auto objIter = se::NativePtrToObjectMap::find(s.nativeThisObject());
+    if(objIter != se::NativePtrToObjectMap::end())
+    {
+        objIter->second->clearPrivateData(true);
+    }
+    return true;
+}
+SE_BIND_FUNC(js_cocos2d_WebView_destroy)
+
+bool js_register_webview_WebView(se::Object* obj)
+{
+    auto cls = se::Class::create("WebView", obj, nullptr, _SE(js_webview_WebView_constructor));
+
+    cls->defineFunction("setOnShouldStartLoading", _SE(js_webview_WebView_setOnShouldStartLoading));
+    cls->defineFunction("setOnDidFailLoading", _SE(js_webview_WebView_setOnDidFailLoading));
+    cls->defineFunction("canGoBack", _SE(js_webview_WebView_canGoBack));
+    cls->defineFunction("loadHTMLString", _SE(js_webview_WebView_loadHTMLString));
+    cls->defineFunction("goForward", _SE(js_webview_WebView_goForward));
+    cls->defineFunction("goBack", _SE(js_webview_WebView_goBack));
+    cls->defineFunction("setScalesPageToFit", _SE(js_webview_WebView_setScalesPageToFit));
+    cls->defineFunction("getOnDidFailLoading", _SE(js_webview_WebView_getOnDidFailLoading));
+    cls->defineFunction("loadFile", _SE(js_webview_WebView_loadFile));
+    cls->defineFunction("loadURL", _SE(js_webview_WebView_loadURL));
+    cls->defineFunction("setBounces", _SE(js_webview_WebView_setBounces));
+    cls->defineFunction("evaluateJS", _SE(js_webview_WebView_evaluateJS));
+    cls->defineFunction("setOnJSCallback", _SE(js_webview_WebView_setOnJSCallback));
+    cls->defineFunction("setBackgroundTransparent", _SE(js_webview_WebView_setBackgroundTransparent));
+    cls->defineFunction("getOnJSCallback", _SE(js_webview_WebView_getOnJSCallback));
+    cls->defineFunction("canGoForward", _SE(js_webview_WebView_canGoForward));
+    cls->defineFunction("getOnShouldStartLoading", _SE(js_webview_WebView_getOnShouldStartLoading));
+    cls->defineFunction("stopLoading", _SE(js_webview_WebView_stopLoading));
+    cls->defineFunction("setFrame", _SE(js_webview_WebView_setFrame));
+    cls->defineFunction("setVisible", _SE(js_webview_WebView_setVisible));
+    cls->defineFunction("reload", _SE(js_webview_WebView_reload));
+    cls->defineFunction("loadData", _SE(js_webview_WebView_loadData));
+    cls->defineFunction("setJavascriptInterfaceScheme", _SE(js_webview_WebView_setJavascriptInterfaceScheme));
+    cls->defineFunction("setOnDidFinishLoading", _SE(js_webview_WebView_setOnDidFinishLoading));
+    cls->defineFunction("getOnDidFinishLoading", _SE(js_webview_WebView_getOnDidFinishLoading));
+    cls->defineFunction("destroy", _SE(js_cocos2d_WebView_destroy));
+    cls->defineStaticFunction("create", _SE(js_webview_WebView_create));
+    cls->defineFinalizeFunction(_SE(js_cocos2d_WebView_finalize));
+    cls->install();
+    JSBClassType::registerClass<cocos2d::WebView>(cls);
+
+    __jsb_cocos2d_WebView_proto = cls->getProto();
+    __jsb_cocos2d_WebView_class = cls;
+
+    se::ScriptEngine::getInstance()->clearException();
+    return true;
+}
+
+bool register_all_webview(se::Object* obj)
+{
+    // Get the ns
+    se::Value nsVal;
+    if (!obj->getProperty("jsb", &nsVal))
+    {
+        se::HandleObject jsobj(se::Object::createPlainObject());
+        nsVal.setObject(jsobj);
+        obj->setProperty("jsb", nsVal);
+    }
+    se::Object* ns = nsVal.toObject();
+
+    js_register_webview_WebView(ns);
+    return true;
+}
+
+#endif //#if (USE_WEB_VIEW > 0) && (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID || CC_TARGET_PLATFORM == CC_PLATFORM_IOS) && !defined(CC_TARGET_OS_TVOS)

cocos2d-x/cocos/scripting/js-bindings/auto/jsb_webview_auto.hpp

@@ -0,0 +1,40 @@
+#pragma once
+#include "base/ccConfig.h"
+#if (USE_WEB_VIEW > 0) && (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID || CC_TARGET_PLATFORM == CC_PLATFORM_IOS) && !defined(CC_TARGET_OS_TVOS)
+
+#include "cocos/scripting/js-bindings/jswrapper/SeApi.h"
+
+extern se::Object* __jsb_cocos2d_WebView_proto;
+extern se::Class* __jsb_cocos2d_WebView_class;
+
+bool js_register_cocos2d_WebView(se::Object* obj);
+bool register_all_webview(se::Object* obj);
+SE_DECLARE_FUNC(js_webview_WebView_setOnShouldStartLoading);
+SE_DECLARE_FUNC(js_webview_WebView_setOnDidFailLoading);
+SE_DECLARE_FUNC(js_webview_WebView_canGoBack);
+SE_DECLARE_FUNC(js_webview_WebView_loadHTMLString);
+SE_DECLARE_FUNC(js_webview_WebView_goForward);
+SE_DECLARE_FUNC(js_webview_WebView_goBack);
+SE_DECLARE_FUNC(js_webview_WebView_setScalesPageToFit);
+SE_DECLARE_FUNC(js_webview_WebView_getOnDidFailLoading);
+SE_DECLARE_FUNC(js_webview_WebView_loadFile);
+SE_DECLARE_FUNC(js_webview_WebView_loadURL);
+SE_DECLARE_FUNC(js_webview_WebView_setBounces);
+SE_DECLARE_FUNC(js_webview_WebView_evaluateJS);
+SE_DECLARE_FUNC(js_webview_WebView_setOnJSCallback);
+SE_DECLARE_FUNC(js_webview_WebView_setBackgroundTransparent);
+SE_DECLARE_FUNC(js_webview_WebView_getOnJSCallback);
+SE_DECLARE_FUNC(js_webview_WebView_canGoForward);
+SE_DECLARE_FUNC(js_webview_WebView_getOnShouldStartLoading);
+SE_DECLARE_FUNC(js_webview_WebView_stopLoading);
+SE_DECLARE_FUNC(js_webview_WebView_setFrame);
+SE_DECLARE_FUNC(js_webview_WebView_setVisible);
+SE_DECLARE_FUNC(js_webview_WebView_reload);
+SE_DECLARE_FUNC(js_webview_WebView_loadData);
+SE_DECLARE_FUNC(js_webview_WebView_setJavascriptInterfaceScheme);
+SE_DECLARE_FUNC(js_webview_WebView_setOnDidFinishLoading);
+SE_DECLARE_FUNC(js_webview_WebView_getOnDidFinishLoading);
+SE_DECLARE_FUNC(js_webview_WebView_create);
+SE_DECLARE_FUNC(js_webview_WebView_WebView);
+
+#endif //#if (USE_WEB_VIEW > 0) && (CC_TARGET_PLATFORM == CC_PLATFORM_ANDROID || CC_TARGET_PLATFORM == CC_PLATFORM_IOS) && !defined(CC_TARGET_OS_TVOS)