JSClass  *jsb_ClippingNode_class;
JSObject *jsb_ClippingNode_prototype;

JSBool js_cocos2dx_ClippingNode_isInverted(JSContext *cx, uint32_t argc, jsval *vp)
{
        JSObject *obj = JS_THIS_OBJECT(cx, vp);
        js_proxy_t *proxy = jsb_get_js_proxy(obj);
        cocos2d::CCClippingNode* cobj = (cocos2d::CCClippingNode *)(proxy ? proxy->ptr : NULL);
        JSB_PRECONDITION2( cobj, cx, JS_FALSE, "Invalid Native Object");
        if (argc == 0) {
                bool ret = cobj->isInverted();
                jsval jsret;
                jsret = BOOLEAN_TO_JSVAL(ret);
                JS_SET_RVAL(cx, vp, jsret);
                return JS_TRUE;
        }
    
        JS_ReportError(cx, "wrong number of arguments: %d, was expecting %d", argc, 0);
        return JS_FALSE;
}
JSBool js_cocos2dx_ClippingNode_visit(JSContext *cx, uint32_t argc, jsval *vp)
{
        JSObject *obj = JS_THIS_OBJECT(cx, vp);
        js_proxy_t *proxy = jsb_get_js_proxy(obj);
        cocos2d::CCClippingNode* cobj = (cocos2d::CCClippingNode *)(proxy ? proxy->ptr : NULL);
        JSB_PRECONDITION2( cobj, cx, JS_FALSE, "Invalid Native Object");
        if (argc == 0) {
                cobj->visit();
                JS_SET_RVAL(cx, vp, JSVAL_VOID);
                return JS_TRUE;
        }
    
        JS_ReportError(cx, "wrong number of arguments: %d, was expecting %d", argc, 0);
        return JS_FALSE;
}
JSBool js_cocos2dx_ClippingNode_setInverted(JSContext *cx, uint32_t argc, jsval *vp)
{
        jsval *argv = JS_ARGV(cx, vp);
        JSBool ok = JS_TRUE;
        JSObject *obj = JS_THIS_OBJECT(cx, vp);
        js_proxy_t *proxy = jsb_get_js_proxy(obj);
        cocos2d::CCClippingNode* cobj = (cocos2d::CCClippingNode *)(proxy ? proxy->ptr : NULL);
        JSB_PRECONDITION2( cobj, cx, JS_FALSE, "Invalid Native Object");
        if (argc == 1) {
                JSBool arg0;
                ok &= JS_ValueToBoolean(cx, argv[0], &arg0;);
                JSB_PRECONDITION2(ok, cx, JS_FALSE, "Error processing arguments");
                cobj->setInverted(arg0);
                JS_SET_RVAL(cx, vp, JSVAL_VOID);
                return JS_TRUE;
        }
    
        JS_ReportError(cx, "wrong number of arguments: %d, was expecting %d", argc, 1);
        return JS_FALSE;
}
JSBool js_cocos2dx_ClippingNode_setStencil(JSContext *cx, uint32_t argc, jsval *vp)
{
        jsval *argv = JS_ARGV(cx, vp);
        JSBool ok = JS_TRUE;
        JSObject *obj = JS_THIS_OBJECT(cx, vp);
        js_proxy_t *proxy = jsb_get_js_proxy(obj);
        cocos2d::CCClippingNode* cobj = (cocos2d::CCClippingNode *)(proxy ? proxy->ptr : NULL);
        JSB_PRECONDITION2( cobj, cx, JS_FALSE, "Invalid Native Object");
        if (argc == 1) {
                cocos2d::CCNode* arg0;
                do {
                        if (!argv[0].isObject()) { ok = JS_FALSE; break; }
                        js_proxy_t *proxy;
                        JSObject *tmpObj = JSVAL_TO_OBJECT(argv[0]);
                        proxy = jsb_get_js_proxy(tmpObj);
                        arg0 = (cocos2d::CCNode*)(proxy ? proxy->ptr : NULL);
                        JSB_PRECONDITION2( arg0, cx, JS_FALSE, "Invalid Native Object");
                } while (0);
                JSB_PRECONDITION2(ok, cx, JS_FALSE, "Error processing arguments");
                cobj->setStencil(arg0);
                JS_SET_RVAL(cx, vp, JSVAL_VOID);
                return JS_TRUE;
        }
    
        JS_ReportError(cx, "wrong number of arguments: %d, was expecting %d", argc, 1);
        return JS_FALSE;
}
JSBool js_cocos2dx_ClippingNode_getAlphaThreshold(JSContext *cx, uint32_t argc, jsval *vp)
{
        JSObject *obj = JS_THIS_OBJECT(cx, vp);
        js_proxy_t *proxy = jsb_get_js_proxy(obj);
        cocos2d::CCClippingNode* cobj = (cocos2d::CCClippingNode *)(proxy ? proxy->ptr : NULL);
        JSB_PRECONDITION2( cobj, cx, JS_FALSE, "Invalid Native Object");
        if (argc == 0) {
                float ret = cobj->getAlphaThreshold();
                jsval jsret;
                jsret = DOUBLE_TO_JSVAL(ret);
                JS_SET_RVAL(cx, vp, jsret);
                return JS_TRUE;
        }
    
        JS_ReportError(cx, "wrong number of arguments: %d, was expecting %d", argc, 0);
        return JS_FALSE;
}
JSBool js_cocos2dx_ClippingNode_init(JSContext *cx, uint32_t argc, jsval *vp)
{
        jsval *argv = JS_ARGV(cx, vp);
        JSBool ok = JS_TRUE;
    
        JSObject *obj = NULL;
        cocos2d::CCClippingNode* cobj = NULL;
        obj = JS_THIS_OBJECT(cx, vp);
        js_proxy_t *proxy = jsb_get_js_proxy(obj);
        cobj = (cocos2d::CCClippingNode *)(proxy ? proxy->ptr : NULL);
        JSB_PRECONDITION2( cobj, cx, JS_FALSE, "Invalid Native Object");
        do {
                if (argc == 1) {
                        cocos2d::CCNode* arg0;
                        do {
                                if (!argv[0].isObject()) { ok = JS_FALSE; break; }
                                js_proxy_t *proxy;
                                JSObject *tmpObj = JSVAL_TO_OBJECT(argv[0]);
                                proxy = jsb_get_js_proxy(tmpObj);
                                arg0 = (cocos2d::CCNode*)(proxy ? proxy->ptr : NULL);
                                JSB_PRECONDITION2( arg0, cx, JS_FALSE, "Invalid Native Object");
                        } while (0);
                        if (!ok) { ok = JS_TRUE; break; }
                        bool ret = cobj->init(arg0);
                        jsval jsret;
                        jsret = BOOLEAN_TO_JSVAL(ret);
                        JS_SET_RVAL(cx, vp, jsret);
                        return JS_TRUE;
                }
        } while(0);
    
        do {
                if (argc == 0) {
                        bool ret = cobj->init();
                        jsval jsret;
                        jsret = BOOLEAN_TO_JSVAL(ret);
                        JS_SET_RVAL(cx, vp, jsret);
                        return JS_TRUE;
                }
        } while(0);
    
        JS_ReportError(cx, "wrong number of arguments");
        return JS_FALSE;
}
JSBool js_cocos2dx_ClippingNode_getStencil(JSContext *cx, uint32_t argc, jsval *vp)
{
        JSObject *obj = JS_THIS_OBJECT(cx, vp);
        js_proxy_t *proxy = jsb_get_js_proxy(obj);
        cocos2d::CCClippingNode* cobj = (cocos2d::CCClippingNode *)(proxy ? proxy->ptr : NULL);
        JSB_PRECONDITION2( cobj, cx, JS_FALSE, "Invalid Native Object");
        if (argc == 0) {
                cocos2d::CCNode* ret = cobj->getStencil();
                jsval jsret;
                do {
                        if (ret) {
                                js_proxy_t *proxy = js_get_or_create_proxy<cocos2d::ccnode>(cx, ret);
                                jsret = OBJECT_TO_JSVAL(proxy->obj);
                        } else {
                                jsret = JSVAL_NULL;
                        }
                } while (0);
                JS_SET_RVAL(cx, vp, jsret);
                return JS_TRUE;
        }
    
        JS_ReportError(cx, "wrong number of arguments: %d, was expecting %d", argc, 0);
        return JS_FALSE;
}
JSBool js_cocos2dx_ClippingNode_setAlphaThreshold(JSContext *cx, uint32_t argc, jsval *vp)
{
        jsval *argv = JS_ARGV(cx, vp);
        JSBool ok = JS_TRUE;
        JSObject *obj = JS_THIS_OBJECT(cx, vp);
        js_proxy_t *proxy = jsb_get_js_proxy(obj);
        cocos2d::CCClippingNode* cobj = (cocos2d::CCClippingNode *)(proxy ? proxy->ptr : NULL);
        JSB_PRECONDITION2( cobj, cx, JS_FALSE, "Invalid Native Object");
        if (argc == 1) {
                double arg0;
                ok &= JS_ValueToNumber(cx, argv[0], &arg0;);
                JSB_PRECONDITION2(ok, cx, JS_FALSE, "Error processing arguments");
                cobj->setAlphaThreshold(arg0);
                JS_SET_RVAL(cx, vp, JSVAL_VOID);
                return JS_TRUE;
        }
    
        JS_ReportError(cx, "wrong number of arguments: %d, was expecting %d", argc, 1);
        return JS_FALSE;
}
JSBool js_cocos2dx_ClippingNode_create(JSContext *cx, uint32_t argc, jsval *vp)
{
        jsval *argv = JS_ARGV(cx, vp);
        JSBool ok = JS_TRUE;
        
        do {
                if (argc == 1) {
                        cocos2d::CCNode* arg0;
                        do {
                                if (!argv[0].isObject()) { ok = JS_FALSE; break; }
                                js_proxy_t *proxy;
                                JSObject *tmpObj = JSVAL_TO_OBJECT(argv[0]);
                                proxy = jsb_get_js_proxy(tmpObj);
                                arg0 = (cocos2d::CCNode*)(proxy ? proxy->ptr : NULL);
                                JSB_PRECONDITION2( arg0, cx, JS_FALSE, "Invalid Native Object");
                        } while (0);
                        if (!ok) { ok = JS_TRUE; break; }
                        cocos2d::CCClippingNode* ret = cocos2d::CCClippingNode::create(arg0);
                        jsval jsret;
                        do {
                                if (ret) {
                                        js_proxy_t *proxy = js_get_or_create_proxy<cocos2d::ccclippingnode>(cx, ret);
                                        jsret = OBJECT_TO_JSVAL(proxy->obj);
                                } else {
                                        jsret = JSVAL_NULL;
                                }
                        } while (0);
                        JS_SET_RVAL(cx, vp, jsret);
                        return JS_TRUE;
                }
        } while (0);
        
        do {
                if (argc == 0) {
                        cocos2d::CCClippingNode* ret = cocos2d::CCClippingNode::create();
                        jsval jsret;
                        do {
                                if (ret) {
                                        js_proxy_t *proxy = js_get_or_create_proxy<cocos2d::ccclippingnode>(cx, ret);
                                        jsret = OBJECT_TO_JSVAL(proxy->obj);
                                } else {
                                        jsret = JSVAL_NULL;
                                }
                        } while (0);
                        JS_SET_RVAL(cx, vp, jsret);
                        return JS_TRUE;
                }
        } while (0);
        JS_ReportError(cx, "wrong number of arguments");
        return JS_FALSE;
}


extern JSObject *jsb_CCNode_prototype;

void js_cocos2dx_ClippingNode_finalize(JSFreeOp *fop, JSObject *obj) {
    CCLOGINFO("jsbindings: finalizing JS object %p (ClippingNode)", obj);
}

void js_register_cocos2dx_ClippingNode(JSContext *cx, JSObject *global) {
        jsb_ClippingNode_class = (JSClass *)calloc(1, sizeof(JSClass));
        jsb_ClippingNode_class->name = "ClippingNode";
        jsb_ClippingNode_class->addProperty = JS_PropertyStub;
        jsb_ClippingNode_class->delProperty = JS_PropertyStub;
        jsb_ClippingNode_class->getProperty = JS_PropertyStub;
        jsb_ClippingNode_class->setProperty = JS_StrictPropertyStub;
        jsb_ClippingNode_class->enumerate = JS_EnumerateStub;
        jsb_ClippingNode_class->resolve = JS_ResolveStub;
        jsb_ClippingNode_class->convert = JS_ConvertStub;
        jsb_ClippingNode_class->finalize = js_cocos2dx_ClippingNode_finalize;
        jsb_ClippingNode_class->flags = JSCLASS_HAS_RESERVED_SLOTS(2);
    
        static JSPropertySpec properties[] = {
                {0, 0, 0, JSOP_NULLWRAPPER, JSOP_NULLWRAPPER}
        };
    
        static JSFunctionSpec funcs[] = {
                JS_FN("isInverted", js_cocos2dx_ClippingNode_isInverted, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE),
                JS_FN("visit", js_cocos2dx_ClippingNode_visit, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE),
                JS_FN("setInverted", js_cocos2dx_ClippingNode_setInverted, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE),
                JS_FN("setStencil", js_cocos2dx_ClippingNode_setStencil, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE),
                JS_FN("getAlphaThreshold", js_cocos2dx_ClippingNode_getAlphaThreshold, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE),
                JS_FN("init", js_cocos2dx_ClippingNode_init, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE),
                JS_FN("getStencil", js_cocos2dx_ClippingNode_getStencil, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE),
                JS_FN("setAlphaThreshold", js_cocos2dx_ClippingNode_setAlphaThreshold, 1, JSPROP_PERMANENT | JSPROP_ENUMERATE),
        JS_FS_END
        };
    
        static JSFunctionSpec st_funcs[] = {
                JS_FN("create", js_cocos2dx_ClippingNode_create, 0, JSPROP_PERMANENT | JSPROP_ENUMERATE),
                JS_FS_END
        };
    
        jsb_ClippingNode_prototype = JS_InitClass(
                                              cx, global,
                                              jsb_CCNode_prototype,
                                              jsb_ClippingNode_class,
                                              empty_constructor, 0,
                                              properties,
                                              funcs,
                                              NULL, // no static properties
                                              st_funcs);
        // make the class enumerable in the registered namespace
        JSBool found;
        JS_SetPropertyAttributes(cx, global, "ClippingNode", JSPROP_ENUMERATE | JSPROP_READONLY, &found;);
    
        // add the proto and JSClass to the type->js info hash table
        TypeTest<cocos2d::ccclippingnode> t;
        js_type_class_t *p;
        uint32_t typeId = t.s_id();
        HASH_FIND_INT(_js_global_type_ht, &typeId;, p);
        if (!p) {
                p = (js_type_class_t *)malloc(sizeof(js_type_class_t));
                p->type = typeId;
                p->jsclass = jsb_ClippingNode_class;
                p->proto = jsb_ClippingNode_prototype;
                p->parentProto = jsb_CCNode_prototype;
                HASH_ADD_INT(_js_global_type_ht, type, p);
        }
}

cocos2d-x 3.0 已经帮定,本代码在 cocos2d-x 2.1.5 下测试通过