mirror of
https://github.com/cocos/cocos4.git
synced 2026-11-20 23:52:40 +08:00
71d8cf11ad
* refine module separate -> gfx renderer * refine module separate * modify Application.mk, add macro * “#if USE_GFX_RENDERER” means “#if USE_GFX_RENDERER > 0” * improve macro define in binding code
1679 lines
71 KiB
C++
1679 lines
71 KiB
C++
#include "scripting/js-bindings/auto/jsb_gfx_auto.hpp"
|
|
#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 "scripting/js-bindings/manual/jsb_conversions.hpp"
|
|
#include "scripting/js-bindings/manual/jsb_global.h"
|
|
#include "renderer/gfx/GFX.h"
|
|
|
|
se::Object* __jsb_cocos2d_renderer_GraphicsHandle_proto = nullptr;
|
|
se::Class* __jsb_cocos2d_renderer_GraphicsHandle_class = nullptr;
|
|
|
|
static bool js_gfx_GraphicsHandle_getHandle(se::State& s)
|
|
{
|
|
cocos2d::renderer::GraphicsHandle* cobj = (cocos2d::renderer::GraphicsHandle*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_GraphicsHandle_getHandle : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 0) {
|
|
unsigned int result = cobj->getHandle();
|
|
ok &= uint32_to_seval(result, &s.rval());
|
|
SE_PRECONDITION2(ok, false, "js_gfx_GraphicsHandle_getHandle : 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_gfx_GraphicsHandle_getHandle)
|
|
|
|
SE_DECLARE_FINALIZE_FUNC(js_cocos2d_renderer_GraphicsHandle_finalize)
|
|
|
|
static bool js_gfx_GraphicsHandle_constructor(se::State& s)
|
|
{
|
|
cocos2d::renderer::GraphicsHandle* cobj = new (std::nothrow) cocos2d::renderer::GraphicsHandle();
|
|
s.thisObject()->setPrivateData(cobj);
|
|
return true;
|
|
}
|
|
SE_BIND_CTOR(js_gfx_GraphicsHandle_constructor, __jsb_cocos2d_renderer_GraphicsHandle_class, js_cocos2d_renderer_GraphicsHandle_finalize)
|
|
|
|
|
|
|
|
|
|
static bool js_cocos2d_renderer_GraphicsHandle_finalize(se::State& s)
|
|
{
|
|
CCLOGINFO("jsbindings: finalizing JS object %p (cocos2d::renderer::GraphicsHandle)", s.nativeThisObject());
|
|
cocos2d::renderer::GraphicsHandle* cobj = (cocos2d::renderer::GraphicsHandle*)s.nativeThisObject();
|
|
cobj->release();
|
|
return true;
|
|
}
|
|
SE_BIND_FINALIZE_FUNC(js_cocos2d_renderer_GraphicsHandle_finalize)
|
|
|
|
bool js_register_gfx_GraphicsHandle(se::Object* obj)
|
|
{
|
|
auto cls = se::Class::create("GraphicsHandle", obj, nullptr, _SE(js_gfx_GraphicsHandle_constructor));
|
|
|
|
cls->defineFunction("getHandle", _SE(js_gfx_GraphicsHandle_getHandle));
|
|
cls->defineFinalizeFunction(_SE(js_cocos2d_renderer_GraphicsHandle_finalize));
|
|
cls->install();
|
|
JSBClassType::registerClass<cocos2d::renderer::GraphicsHandle>(cls);
|
|
|
|
__jsb_cocos2d_renderer_GraphicsHandle_proto = cls->getProto();
|
|
__jsb_cocos2d_renderer_GraphicsHandle_class = cls;
|
|
|
|
se::ScriptEngine::getInstance()->clearException();
|
|
return true;
|
|
}
|
|
|
|
se::Object* __jsb_cocos2d_renderer_IndexBuffer_proto = nullptr;
|
|
se::Class* __jsb_cocos2d_renderer_IndexBuffer_class = nullptr;
|
|
|
|
static bool js_gfx_IndexBuffer_setBytes(se::State& s)
|
|
{
|
|
cocos2d::renderer::IndexBuffer* cobj = (cocos2d::renderer::IndexBuffer*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_IndexBuffer_setBytes : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 1) {
|
|
unsigned int arg0 = 0;
|
|
ok &= seval_to_uint32(args[0], (uint32_t*)&arg0);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_IndexBuffer_setBytes : Error processing arguments");
|
|
cobj->setBytes(arg0);
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_IndexBuffer_setBytes)
|
|
|
|
static bool js_gfx_IndexBuffer_getUsage(se::State& s)
|
|
{
|
|
cocos2d::renderer::IndexBuffer* cobj = (cocos2d::renderer::IndexBuffer*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_IndexBuffer_getUsage : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 0) {
|
|
int result = (int)cobj->getUsage();
|
|
ok &= int32_to_seval(result, &s.rval());
|
|
SE_PRECONDITION2(ok, false, "js_gfx_IndexBuffer_getUsage : 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_gfx_IndexBuffer_getUsage)
|
|
|
|
static bool js_gfx_IndexBuffer_setFormat(se::State& s)
|
|
{
|
|
cocos2d::renderer::IndexBuffer* cobj = (cocos2d::renderer::IndexBuffer*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_IndexBuffer_setFormat : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 1) {
|
|
cocos2d::renderer::IndexFormat arg0;
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (cocos2d::renderer::IndexFormat)tmp; } while(false);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_IndexBuffer_setFormat : Error processing arguments");
|
|
cobj->setFormat(arg0);
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_IndexBuffer_setFormat)
|
|
|
|
static bool js_gfx_IndexBuffer_setCount(se::State& s)
|
|
{
|
|
cocos2d::renderer::IndexBuffer* cobj = (cocos2d::renderer::IndexBuffer*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_IndexBuffer_setCount : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 1) {
|
|
unsigned int arg0 = 0;
|
|
ok &= seval_to_uint32(args[0], (uint32_t*)&arg0);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_IndexBuffer_setCount : Error processing arguments");
|
|
cobj->setCount(arg0);
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_IndexBuffer_setCount)
|
|
|
|
static bool js_gfx_IndexBuffer_destroy(se::State& s)
|
|
{
|
|
cocos2d::renderer::IndexBuffer* cobj = (cocos2d::renderer::IndexBuffer*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_IndexBuffer_destroy : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
if (argc == 0) {
|
|
cobj->destroy();
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_IndexBuffer_destroy)
|
|
|
|
static bool js_gfx_IndexBuffer_setUsage(se::State& s)
|
|
{
|
|
cocos2d::renderer::IndexBuffer* cobj = (cocos2d::renderer::IndexBuffer*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_IndexBuffer_setUsage : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 1) {
|
|
cocos2d::renderer::Usage arg0;
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (cocos2d::renderer::Usage)tmp; } while(false);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_IndexBuffer_setUsage : Error processing arguments");
|
|
cobj->setUsage(arg0);
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_IndexBuffer_setUsage)
|
|
|
|
static bool js_gfx_IndexBuffer_getCount(se::State& s)
|
|
{
|
|
cocos2d::renderer::IndexBuffer* cobj = (cocos2d::renderer::IndexBuffer*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_IndexBuffer_getCount : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 0) {
|
|
unsigned int result = cobj->getCount();
|
|
ok &= uint32_to_seval(result, &s.rval());
|
|
SE_PRECONDITION2(ok, false, "js_gfx_IndexBuffer_getCount : 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_gfx_IndexBuffer_getCount)
|
|
|
|
static bool js_gfx_IndexBuffer_setBytesPerIndex(se::State& s)
|
|
{
|
|
cocos2d::renderer::IndexBuffer* cobj = (cocos2d::renderer::IndexBuffer*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_IndexBuffer_setBytesPerIndex : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 1) {
|
|
unsigned int arg0 = 0;
|
|
ok &= seval_to_uint32(args[0], (uint32_t*)&arg0);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_IndexBuffer_setBytesPerIndex : Error processing arguments");
|
|
cobj->setBytesPerIndex(arg0);
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_IndexBuffer_setBytesPerIndex)
|
|
|
|
static bool js_gfx_IndexBuffer_getBytes(se::State& s)
|
|
{
|
|
cocos2d::renderer::IndexBuffer* cobj = (cocos2d::renderer::IndexBuffer*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_IndexBuffer_getBytes : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 0) {
|
|
unsigned int result = cobj->getBytes();
|
|
ok &= uint32_to_seval(result, &s.rval());
|
|
SE_PRECONDITION2(ok, false, "js_gfx_IndexBuffer_getBytes : 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_gfx_IndexBuffer_getBytes)
|
|
|
|
SE_DECLARE_FINALIZE_FUNC(js_cocos2d_renderer_IndexBuffer_finalize)
|
|
|
|
static bool js_gfx_IndexBuffer_constructor(se::State& s)
|
|
{
|
|
cocos2d::renderer::IndexBuffer* cobj = new (std::nothrow) cocos2d::renderer::IndexBuffer();
|
|
s.thisObject()->setPrivateData(cobj);
|
|
return true;
|
|
}
|
|
SE_BIND_CTOR(js_gfx_IndexBuffer_constructor, __jsb_cocos2d_renderer_IndexBuffer_class, js_cocos2d_renderer_IndexBuffer_finalize)
|
|
|
|
|
|
|
|
extern se::Object* __jsb_cocos2d_renderer_GraphicsHandle_proto;
|
|
|
|
static bool js_cocos2d_renderer_IndexBuffer_finalize(se::State& s)
|
|
{
|
|
CCLOGINFO("jsbindings: finalizing JS object %p (cocos2d::renderer::IndexBuffer)", s.nativeThisObject());
|
|
cocos2d::renderer::IndexBuffer* cobj = (cocos2d::renderer::IndexBuffer*)s.nativeThisObject();
|
|
cobj->release();
|
|
return true;
|
|
}
|
|
SE_BIND_FINALIZE_FUNC(js_cocos2d_renderer_IndexBuffer_finalize)
|
|
|
|
bool js_register_gfx_IndexBuffer(se::Object* obj)
|
|
{
|
|
auto cls = se::Class::create("IndexBuffer", obj, __jsb_cocos2d_renderer_GraphicsHandle_proto, _SE(js_gfx_IndexBuffer_constructor));
|
|
|
|
cls->defineFunction("setBytes", _SE(js_gfx_IndexBuffer_setBytes));
|
|
cls->defineFunction("getUsage", _SE(js_gfx_IndexBuffer_getUsage));
|
|
cls->defineFunction("setFormat", _SE(js_gfx_IndexBuffer_setFormat));
|
|
cls->defineFunction("setCount", _SE(js_gfx_IndexBuffer_setCount));
|
|
cls->defineFunction("destroy", _SE(js_gfx_IndexBuffer_destroy));
|
|
cls->defineFunction("setUsage", _SE(js_gfx_IndexBuffer_setUsage));
|
|
cls->defineFunction("getCount", _SE(js_gfx_IndexBuffer_getCount));
|
|
cls->defineFunction("setBytesPerIndex", _SE(js_gfx_IndexBuffer_setBytesPerIndex));
|
|
cls->defineFunction("getBytes", _SE(js_gfx_IndexBuffer_getBytes));
|
|
cls->defineFinalizeFunction(_SE(js_cocos2d_renderer_IndexBuffer_finalize));
|
|
cls->install();
|
|
JSBClassType::registerClass<cocos2d::renderer::IndexBuffer>(cls);
|
|
|
|
__jsb_cocos2d_renderer_IndexBuffer_proto = cls->getProto();
|
|
__jsb_cocos2d_renderer_IndexBuffer_class = cls;
|
|
|
|
se::ScriptEngine::getInstance()->clearException();
|
|
return true;
|
|
}
|
|
|
|
se::Object* __jsb_cocos2d_renderer_VertexBuffer_proto = nullptr;
|
|
se::Class* __jsb_cocos2d_renderer_VertexBuffer_class = nullptr;
|
|
|
|
static bool js_gfx_VertexBuffer_setBytes(se::State& s)
|
|
{
|
|
cocos2d::renderer::VertexBuffer* cobj = (cocos2d::renderer::VertexBuffer*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_VertexBuffer_setBytes : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 1) {
|
|
unsigned int arg0 = 0;
|
|
ok &= seval_to_uint32(args[0], (uint32_t*)&arg0);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_VertexBuffer_setBytes : Error processing arguments");
|
|
cobj->setBytes(arg0);
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_VertexBuffer_setBytes)
|
|
|
|
static bool js_gfx_VertexBuffer_getUsage(se::State& s)
|
|
{
|
|
cocos2d::renderer::VertexBuffer* cobj = (cocos2d::renderer::VertexBuffer*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_VertexBuffer_getUsage : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 0) {
|
|
int result = (int)cobj->getUsage();
|
|
ok &= int32_to_seval(result, &s.rval());
|
|
SE_PRECONDITION2(ok, false, "js_gfx_VertexBuffer_getUsage : 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_gfx_VertexBuffer_getUsage)
|
|
|
|
static bool js_gfx_VertexBuffer_setCount(se::State& s)
|
|
{
|
|
cocos2d::renderer::VertexBuffer* cobj = (cocos2d::renderer::VertexBuffer*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_VertexBuffer_setCount : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 1) {
|
|
unsigned int arg0 = 0;
|
|
ok &= seval_to_uint32(args[0], (uint32_t*)&arg0);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_VertexBuffer_setCount : Error processing arguments");
|
|
cobj->setCount(arg0);
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_VertexBuffer_setCount)
|
|
|
|
static bool js_gfx_VertexBuffer_destroy(se::State& s)
|
|
{
|
|
cocos2d::renderer::VertexBuffer* cobj = (cocos2d::renderer::VertexBuffer*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_VertexBuffer_destroy : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
if (argc == 0) {
|
|
cobj->destroy();
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_VertexBuffer_destroy)
|
|
|
|
static bool js_gfx_VertexBuffer_setUsage(se::State& s)
|
|
{
|
|
cocos2d::renderer::VertexBuffer* cobj = (cocos2d::renderer::VertexBuffer*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_VertexBuffer_setUsage : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 1) {
|
|
cocos2d::renderer::Usage arg0;
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (cocos2d::renderer::Usage)tmp; } while(false);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_VertexBuffer_setUsage : Error processing arguments");
|
|
cobj->setUsage(arg0);
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_VertexBuffer_setUsage)
|
|
|
|
static bool js_gfx_VertexBuffer_getCount(se::State& s)
|
|
{
|
|
cocos2d::renderer::VertexBuffer* cobj = (cocos2d::renderer::VertexBuffer*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_VertexBuffer_getCount : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 0) {
|
|
unsigned int result = cobj->getCount();
|
|
ok &= uint32_to_seval(result, &s.rval());
|
|
SE_PRECONDITION2(ok, false, "js_gfx_VertexBuffer_getCount : 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_gfx_VertexBuffer_getCount)
|
|
|
|
static bool js_gfx_VertexBuffer_getBytes(se::State& s)
|
|
{
|
|
cocos2d::renderer::VertexBuffer* cobj = (cocos2d::renderer::VertexBuffer*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_VertexBuffer_getBytes : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 0) {
|
|
unsigned int result = cobj->getBytes();
|
|
ok &= uint32_to_seval(result, &s.rval());
|
|
SE_PRECONDITION2(ok, false, "js_gfx_VertexBuffer_getBytes : 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_gfx_VertexBuffer_getBytes)
|
|
|
|
SE_DECLARE_FINALIZE_FUNC(js_cocos2d_renderer_VertexBuffer_finalize)
|
|
|
|
static bool js_gfx_VertexBuffer_constructor(se::State& s)
|
|
{
|
|
cocos2d::renderer::VertexBuffer* cobj = new (std::nothrow) cocos2d::renderer::VertexBuffer();
|
|
s.thisObject()->setPrivateData(cobj);
|
|
return true;
|
|
}
|
|
SE_BIND_CTOR(js_gfx_VertexBuffer_constructor, __jsb_cocos2d_renderer_VertexBuffer_class, js_cocos2d_renderer_VertexBuffer_finalize)
|
|
|
|
|
|
|
|
extern se::Object* __jsb_cocos2d_renderer_GraphicsHandle_proto;
|
|
|
|
static bool js_cocos2d_renderer_VertexBuffer_finalize(se::State& s)
|
|
{
|
|
CCLOGINFO("jsbindings: finalizing JS object %p (cocos2d::renderer::VertexBuffer)", s.nativeThisObject());
|
|
cocos2d::renderer::VertexBuffer* cobj = (cocos2d::renderer::VertexBuffer*)s.nativeThisObject();
|
|
cobj->release();
|
|
return true;
|
|
}
|
|
SE_BIND_FINALIZE_FUNC(js_cocos2d_renderer_VertexBuffer_finalize)
|
|
|
|
bool js_register_gfx_VertexBuffer(se::Object* obj)
|
|
{
|
|
auto cls = se::Class::create("VertexBuffer", obj, __jsb_cocos2d_renderer_GraphicsHandle_proto, _SE(js_gfx_VertexBuffer_constructor));
|
|
|
|
cls->defineFunction("setBytes", _SE(js_gfx_VertexBuffer_setBytes));
|
|
cls->defineFunction("getUsage", _SE(js_gfx_VertexBuffer_getUsage));
|
|
cls->defineFunction("setCount", _SE(js_gfx_VertexBuffer_setCount));
|
|
cls->defineFunction("destroy", _SE(js_gfx_VertexBuffer_destroy));
|
|
cls->defineFunction("setUsage", _SE(js_gfx_VertexBuffer_setUsage));
|
|
cls->defineFunction("getCount", _SE(js_gfx_VertexBuffer_getCount));
|
|
cls->defineFunction("getBytes", _SE(js_gfx_VertexBuffer_getBytes));
|
|
cls->defineFinalizeFunction(_SE(js_cocos2d_renderer_VertexBuffer_finalize));
|
|
cls->install();
|
|
JSBClassType::registerClass<cocos2d::renderer::VertexBuffer>(cls);
|
|
|
|
__jsb_cocos2d_renderer_VertexBuffer_proto = cls->getProto();
|
|
__jsb_cocos2d_renderer_VertexBuffer_class = cls;
|
|
|
|
se::ScriptEngine::getInstance()->clearException();
|
|
return true;
|
|
}
|
|
|
|
se::Object* __jsb_cocos2d_renderer_DeviceGraphics_proto = nullptr;
|
|
se::Class* __jsb_cocos2d_renderer_DeviceGraphics_class = nullptr;
|
|
|
|
static bool js_gfx_DeviceGraphics_setTexture(se::State& s)
|
|
{
|
|
cocos2d::renderer::DeviceGraphics* cobj = (cocos2d::renderer::DeviceGraphics*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_DeviceGraphics_setTexture : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 3) {
|
|
std::string arg0;
|
|
cocos2d::renderer::Texture* arg1 = nullptr;
|
|
int arg2 = 0;
|
|
ok &= seval_to_std_string(args[0], &arg0);
|
|
ok &= seval_to_native_ptr(args[1], &arg1);
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[2], &tmp); arg2 = (int)tmp; } while(false);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_DeviceGraphics_setTexture : Error processing arguments");
|
|
cobj->setTexture(arg0, arg1, arg2);
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_DeviceGraphics_setTexture)
|
|
|
|
static bool js_gfx_DeviceGraphics_setBlendFuncSeparate(se::State& s)
|
|
{
|
|
cocos2d::renderer::DeviceGraphics* cobj = (cocos2d::renderer::DeviceGraphics*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_DeviceGraphics_setBlendFuncSeparate : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 4) {
|
|
cocos2d::renderer::BlendFactor arg0;
|
|
cocos2d::renderer::BlendFactor arg1;
|
|
cocos2d::renderer::BlendFactor arg2;
|
|
cocos2d::renderer::BlendFactor arg3;
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (cocos2d::renderer::BlendFactor)tmp; } while(false);
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[1], &tmp); arg1 = (cocos2d::renderer::BlendFactor)tmp; } while(false);
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[2], &tmp); arg2 = (cocos2d::renderer::BlendFactor)tmp; } while(false);
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[3], &tmp); arg3 = (cocos2d::renderer::BlendFactor)tmp; } while(false);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_DeviceGraphics_setBlendFuncSeparate : Error processing arguments");
|
|
cobj->setBlendFuncSeparate(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_gfx_DeviceGraphics_setBlendFuncSeparate)
|
|
|
|
static bool js_gfx_DeviceGraphics_enableBlend(se::State& s)
|
|
{
|
|
cocos2d::renderer::DeviceGraphics* cobj = (cocos2d::renderer::DeviceGraphics*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_DeviceGraphics_enableBlend : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
if (argc == 0) {
|
|
cobj->enableBlend();
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_DeviceGraphics_enableBlend)
|
|
|
|
static bool js_gfx_DeviceGraphics_setPrimitiveType(se::State& s)
|
|
{
|
|
cocos2d::renderer::DeviceGraphics* cobj = (cocos2d::renderer::DeviceGraphics*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_DeviceGraphics_setPrimitiveType : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 1) {
|
|
cocos2d::renderer::PrimitiveType arg0;
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (cocos2d::renderer::PrimitiveType)tmp; } while(false);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_DeviceGraphics_setPrimitiveType : Error processing arguments");
|
|
cobj->setPrimitiveType(arg0);
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_DeviceGraphics_setPrimitiveType)
|
|
|
|
static bool js_gfx_DeviceGraphics_setBlendEquationSeparate(se::State& s)
|
|
{
|
|
cocos2d::renderer::DeviceGraphics* cobj = (cocos2d::renderer::DeviceGraphics*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_DeviceGraphics_setBlendEquationSeparate : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 2) {
|
|
cocos2d::renderer::BlendOp arg0;
|
|
cocos2d::renderer::BlendOp arg1;
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (cocos2d::renderer::BlendOp)tmp; } while(false);
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[1], &tmp); arg1 = (cocos2d::renderer::BlendOp)tmp; } while(false);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_DeviceGraphics_setBlendEquationSeparate : Error processing arguments");
|
|
cobj->setBlendEquationSeparate(arg0, arg1);
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_DeviceGraphics_setBlendEquationSeparate)
|
|
|
|
static bool js_gfx_DeviceGraphics_setIndexBuffer(se::State& s)
|
|
{
|
|
cocos2d::renderer::DeviceGraphics* cobj = (cocos2d::renderer::DeviceGraphics*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_DeviceGraphics_setIndexBuffer : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 1) {
|
|
cocos2d::renderer::IndexBuffer* arg0 = nullptr;
|
|
ok &= seval_to_native_ptr(args[0], &arg0);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_DeviceGraphics_setIndexBuffer : Error processing arguments");
|
|
cobj->setIndexBuffer(arg0);
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_DeviceGraphics_setIndexBuffer)
|
|
|
|
static bool js_gfx_DeviceGraphics_setProgram(se::State& s)
|
|
{
|
|
cocos2d::renderer::DeviceGraphics* cobj = (cocos2d::renderer::DeviceGraphics*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_DeviceGraphics_setProgram : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 1) {
|
|
cocos2d::renderer::Program* arg0 = nullptr;
|
|
ok &= seval_to_native_ptr(args[0], &arg0);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_DeviceGraphics_setProgram : Error processing arguments");
|
|
cobj->setProgram(arg0);
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_DeviceGraphics_setProgram)
|
|
|
|
static bool js_gfx_DeviceGraphics_setFrameBuffer(se::State& s)
|
|
{
|
|
cocos2d::renderer::DeviceGraphics* cobj = (cocos2d::renderer::DeviceGraphics*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_DeviceGraphics_setFrameBuffer : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 1) {
|
|
const cocos2d::renderer::FrameBuffer* arg0 = nullptr;
|
|
ok &= seval_to_native_ptr(args[0], &arg0);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_DeviceGraphics_setFrameBuffer : Error processing arguments");
|
|
cobj->setFrameBuffer(arg0);
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_DeviceGraphics_setFrameBuffer)
|
|
|
|
static bool js_gfx_DeviceGraphics_setStencilFunc(se::State& s)
|
|
{
|
|
cocos2d::renderer::DeviceGraphics* cobj = (cocos2d::renderer::DeviceGraphics*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_DeviceGraphics_setStencilFunc : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 3) {
|
|
cocos2d::renderer::ComparisonFunc arg0;
|
|
int arg1 = 0;
|
|
unsigned int arg2 = 0;
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (cocos2d::renderer::ComparisonFunc)tmp; } while(false);
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[1], &tmp); arg1 = (int)tmp; } while(false);
|
|
ok &= seval_to_uint32(args[2], (uint32_t*)&arg2);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_DeviceGraphics_setStencilFunc : Error processing arguments");
|
|
cobj->setStencilFunc(arg0, arg1, arg2);
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_DeviceGraphics_setStencilFunc)
|
|
|
|
static bool js_gfx_DeviceGraphics_setBlendColor(se::State& s)
|
|
{
|
|
CC_UNUSED bool ok = true;
|
|
cocos2d::renderer::DeviceGraphics* cobj = (cocos2d::renderer::DeviceGraphics*)s.nativeThisObject();
|
|
SE_PRECONDITION2( cobj, false, "js_gfx_DeviceGraphics_setBlendColor : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
do {
|
|
if (argc == 4) {
|
|
uint8_t arg0;
|
|
ok &= seval_to_uint8(args[0], (uint8_t*)&arg0);
|
|
if (!ok) { ok = true; break; }
|
|
uint8_t arg1;
|
|
ok &= seval_to_uint8(args[1], (uint8_t*)&arg1);
|
|
if (!ok) { ok = true; break; }
|
|
uint8_t arg2;
|
|
ok &= seval_to_uint8(args[2], (uint8_t*)&arg2);
|
|
if (!ok) { ok = true; break; }
|
|
uint8_t arg3;
|
|
ok &= seval_to_uint8(args[3], (uint8_t*)&arg3);
|
|
if (!ok) { ok = true; break; }
|
|
cobj->setBlendColor(arg0, arg1, arg2, arg3);
|
|
return true;
|
|
}
|
|
} while(false);
|
|
|
|
do {
|
|
if (argc == 1) {
|
|
unsigned int arg0 = 0;
|
|
ok &= seval_to_uint32(args[0], (uint32_t*)&arg0);
|
|
if (!ok) { ok = true; break; }
|
|
cobj->setBlendColor(arg0);
|
|
return true;
|
|
}
|
|
} while(false);
|
|
|
|
SE_REPORT_ERROR("wrong number of arguments: %d", (int)argc);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_DeviceGraphics_setBlendColor)
|
|
|
|
static bool js_gfx_DeviceGraphics_setScissor(se::State& s)
|
|
{
|
|
cocos2d::renderer::DeviceGraphics* cobj = (cocos2d::renderer::DeviceGraphics*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_DeviceGraphics_setScissor : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 4) {
|
|
int arg0 = 0;
|
|
int arg1 = 0;
|
|
int arg2 = 0;
|
|
int arg3 = 0;
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (int)tmp; } while(false);
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[1], &tmp); arg1 = (int)tmp; } while(false);
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[2], &tmp); arg2 = (int)tmp; } while(false);
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[3], &tmp); arg3 = (int)tmp; } while(false);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_DeviceGraphics_setScissor : Error processing arguments");
|
|
cobj->setScissor(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_gfx_DeviceGraphics_setScissor)
|
|
|
|
static bool js_gfx_DeviceGraphics_setVertexBuffer(se::State& s)
|
|
{
|
|
cocos2d::renderer::DeviceGraphics* cobj = (cocos2d::renderer::DeviceGraphics*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_DeviceGraphics_setVertexBuffer : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 2) {
|
|
int arg0 = 0;
|
|
cocos2d::renderer::VertexBuffer* arg1 = nullptr;
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (int)tmp; } while(false);
|
|
ok &= seval_to_native_ptr(args[1], &arg1);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_DeviceGraphics_setVertexBuffer : Error processing arguments");
|
|
cobj->setVertexBuffer(arg0, arg1);
|
|
return true;
|
|
}
|
|
if (argc == 3) {
|
|
int arg0 = 0;
|
|
cocos2d::renderer::VertexBuffer* arg1 = nullptr;
|
|
int arg2 = 0;
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (int)tmp; } while(false);
|
|
ok &= seval_to_native_ptr(args[1], &arg1);
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[2], &tmp); arg2 = (int)tmp; } while(false);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_DeviceGraphics_setVertexBuffer : Error processing arguments");
|
|
cobj->setVertexBuffer(arg0, arg1, arg2);
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_DeviceGraphics_setVertexBuffer)
|
|
|
|
static bool js_gfx_DeviceGraphics_enableDepthWrite(se::State& s)
|
|
{
|
|
cocos2d::renderer::DeviceGraphics* cobj = (cocos2d::renderer::DeviceGraphics*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_DeviceGraphics_enableDepthWrite : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
if (argc == 0) {
|
|
cobj->enableDepthWrite();
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_DeviceGraphics_enableDepthWrite)
|
|
|
|
static bool js_gfx_DeviceGraphics_setTextureArray(se::State& s)
|
|
{
|
|
cocos2d::renderer::DeviceGraphics* cobj = (cocos2d::renderer::DeviceGraphics*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_DeviceGraphics_setTextureArray : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 3) {
|
|
std::string arg0;
|
|
std::vector<cocos2d::renderer::Texture *> arg1;
|
|
std::vector<int> arg2;
|
|
ok &= seval_to_std_string(args[0], &arg0);
|
|
ok &= seval_to_std_vector_Texture(args[1], &arg1);
|
|
ok &= seval_to_std_vector_int(args[2], &arg2);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_DeviceGraphics_setTextureArray : Error processing arguments");
|
|
cobj->setTextureArray(arg0, arg1, arg2);
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_DeviceGraphics_setTextureArray)
|
|
|
|
static bool js_gfx_DeviceGraphics_getCapacity(se::State& s)
|
|
{
|
|
cocos2d::renderer::DeviceGraphics* cobj = (cocos2d::renderer::DeviceGraphics*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_DeviceGraphics_getCapacity : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 0) {
|
|
const cocos2d::renderer::DeviceGraphics::Capacity& result = cobj->getCapacity();
|
|
#pragma warning NO CONVERSION FROM NATIVE FOR Capacity;
|
|
SE_PRECONDITION2(ok, false, "js_gfx_DeviceGraphics_getCapacity : 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_gfx_DeviceGraphics_getCapacity)
|
|
|
|
static bool js_gfx_DeviceGraphics_setStencilOpBack(se::State& s)
|
|
{
|
|
cocos2d::renderer::DeviceGraphics* cobj = (cocos2d::renderer::DeviceGraphics*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_DeviceGraphics_setStencilOpBack : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 4) {
|
|
cocos2d::renderer::StencilOp arg0;
|
|
cocos2d::renderer::StencilOp arg1;
|
|
cocos2d::renderer::StencilOp arg2;
|
|
unsigned int arg3 = 0;
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (cocos2d::renderer::StencilOp)tmp; } while(false);
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[1], &tmp); arg1 = (cocos2d::renderer::StencilOp)tmp; } while(false);
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[2], &tmp); arg2 = (cocos2d::renderer::StencilOp)tmp; } while(false);
|
|
ok &= seval_to_uint32(args[3], (uint32_t*)&arg3);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_DeviceGraphics_setStencilOpBack : Error processing arguments");
|
|
cobj->setStencilOpBack(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_gfx_DeviceGraphics_setStencilOpBack)
|
|
|
|
static bool js_gfx_DeviceGraphics_setViewport(se::State& s)
|
|
{
|
|
cocos2d::renderer::DeviceGraphics* cobj = (cocos2d::renderer::DeviceGraphics*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_DeviceGraphics_setViewport : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 4) {
|
|
int arg0 = 0;
|
|
int arg1 = 0;
|
|
int arg2 = 0;
|
|
int arg3 = 0;
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (int)tmp; } while(false);
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[1], &tmp); arg1 = (int)tmp; } while(false);
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[2], &tmp); arg2 = (int)tmp; } while(false);
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[3], &tmp); arg3 = (int)tmp; } while(false);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_DeviceGraphics_setViewport : Error processing arguments");
|
|
cobj->setViewport(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_gfx_DeviceGraphics_setViewport)
|
|
|
|
static bool js_gfx_DeviceGraphics_draw(se::State& s)
|
|
{
|
|
cocos2d::renderer::DeviceGraphics* cobj = (cocos2d::renderer::DeviceGraphics*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_DeviceGraphics_draw : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 2) {
|
|
size_t arg0 = 0;
|
|
int arg1 = 0;
|
|
ok &= seval_to_size(args[0], &arg0);
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[1], &tmp); arg1 = (int)tmp; } while(false);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_DeviceGraphics_draw : Error processing arguments");
|
|
cobj->draw(arg0, arg1);
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_DeviceGraphics_draw)
|
|
|
|
static bool js_gfx_DeviceGraphics_setDepthFunc(se::State& s)
|
|
{
|
|
cocos2d::renderer::DeviceGraphics* cobj = (cocos2d::renderer::DeviceGraphics*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_DeviceGraphics_setDepthFunc : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 1) {
|
|
cocos2d::renderer::ComparisonFunc arg0;
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (cocos2d::renderer::ComparisonFunc)tmp; } while(false);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_DeviceGraphics_setDepthFunc : Error processing arguments");
|
|
cobj->setDepthFunc(arg0);
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_DeviceGraphics_setDepthFunc)
|
|
|
|
static bool js_gfx_DeviceGraphics_enableDepthTest(se::State& s)
|
|
{
|
|
cocos2d::renderer::DeviceGraphics* cobj = (cocos2d::renderer::DeviceGraphics*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_DeviceGraphics_enableDepthTest : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
if (argc == 0) {
|
|
cobj->enableDepthTest();
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_DeviceGraphics_enableDepthTest)
|
|
|
|
static bool js_gfx_DeviceGraphics_setBlendEquation(se::State& s)
|
|
{
|
|
cocos2d::renderer::DeviceGraphics* cobj = (cocos2d::renderer::DeviceGraphics*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_DeviceGraphics_setBlendEquation : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 1) {
|
|
cocos2d::renderer::BlendOp arg0;
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (cocos2d::renderer::BlendOp)tmp; } while(false);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_DeviceGraphics_setBlendEquation : Error processing arguments");
|
|
cobj->setBlendEquation(arg0);
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_DeviceGraphics_setBlendEquation)
|
|
|
|
static bool js_gfx_DeviceGraphics_setStencilFuncFront(se::State& s)
|
|
{
|
|
cocos2d::renderer::DeviceGraphics* cobj = (cocos2d::renderer::DeviceGraphics*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_DeviceGraphics_setStencilFuncFront : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 3) {
|
|
cocos2d::renderer::ComparisonFunc arg0;
|
|
int arg1 = 0;
|
|
unsigned int arg2 = 0;
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (cocos2d::renderer::ComparisonFunc)tmp; } while(false);
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[1], &tmp); arg1 = (int)tmp; } while(false);
|
|
ok &= seval_to_uint32(args[2], (uint32_t*)&arg2);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_DeviceGraphics_setStencilFuncFront : Error processing arguments");
|
|
cobj->setStencilFuncFront(arg0, arg1, arg2);
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_DeviceGraphics_setStencilFuncFront)
|
|
|
|
static bool js_gfx_DeviceGraphics_setStencilOpFront(se::State& s)
|
|
{
|
|
cocos2d::renderer::DeviceGraphics* cobj = (cocos2d::renderer::DeviceGraphics*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_DeviceGraphics_setStencilOpFront : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 4) {
|
|
cocos2d::renderer::StencilOp arg0;
|
|
cocos2d::renderer::StencilOp arg1;
|
|
cocos2d::renderer::StencilOp arg2;
|
|
unsigned int arg3 = 0;
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (cocos2d::renderer::StencilOp)tmp; } while(false);
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[1], &tmp); arg1 = (cocos2d::renderer::StencilOp)tmp; } while(false);
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[2], &tmp); arg2 = (cocos2d::renderer::StencilOp)tmp; } while(false);
|
|
ok &= seval_to_uint32(args[3], (uint32_t*)&arg3);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_DeviceGraphics_setStencilOpFront : Error processing arguments");
|
|
cobj->setStencilOpFront(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_gfx_DeviceGraphics_setStencilOpFront)
|
|
|
|
static bool js_gfx_DeviceGraphics_setStencilFuncBack(se::State& s)
|
|
{
|
|
cocos2d::renderer::DeviceGraphics* cobj = (cocos2d::renderer::DeviceGraphics*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_DeviceGraphics_setStencilFuncBack : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 3) {
|
|
cocos2d::renderer::ComparisonFunc arg0;
|
|
int arg1 = 0;
|
|
unsigned int arg2 = 0;
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (cocos2d::renderer::ComparisonFunc)tmp; } while(false);
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[1], &tmp); arg1 = (int)tmp; } while(false);
|
|
ok &= seval_to_uint32(args[2], (uint32_t*)&arg2);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_DeviceGraphics_setStencilFuncBack : Error processing arguments");
|
|
cobj->setStencilFuncBack(arg0, arg1, arg2);
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_DeviceGraphics_setStencilFuncBack)
|
|
|
|
static bool js_gfx_DeviceGraphics_setBlendFunc(se::State& s)
|
|
{
|
|
cocos2d::renderer::DeviceGraphics* cobj = (cocos2d::renderer::DeviceGraphics*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_DeviceGraphics_setBlendFunc : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 2) {
|
|
cocos2d::renderer::BlendFactor arg0;
|
|
cocos2d::renderer::BlendFactor arg1;
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (cocos2d::renderer::BlendFactor)tmp; } while(false);
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[1], &tmp); arg1 = (cocos2d::renderer::BlendFactor)tmp; } while(false);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_DeviceGraphics_setBlendFunc : Error processing arguments");
|
|
cobj->setBlendFunc(arg0, arg1);
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_DeviceGraphics_setBlendFunc)
|
|
|
|
static bool js_gfx_DeviceGraphics_setCullMode(se::State& s)
|
|
{
|
|
cocos2d::renderer::DeviceGraphics* cobj = (cocos2d::renderer::DeviceGraphics*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_DeviceGraphics_setCullMode : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 1) {
|
|
cocos2d::renderer::CullMode arg0;
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (cocos2d::renderer::CullMode)tmp; } while(false);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_DeviceGraphics_setCullMode : Error processing arguments");
|
|
cobj->setCullMode(arg0);
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_DeviceGraphics_setCullMode)
|
|
|
|
static bool js_gfx_DeviceGraphics_supportGLExtension(se::State& s)
|
|
{
|
|
cocos2d::renderer::DeviceGraphics* cobj = (cocos2d::renderer::DeviceGraphics*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_DeviceGraphics_supportGLExtension : 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_gfx_DeviceGraphics_supportGLExtension : Error processing arguments");
|
|
bool result = cobj->supportGLExtension(arg0);
|
|
ok &= boolean_to_seval(result, &s.rval());
|
|
SE_PRECONDITION2(ok, false, "js_gfx_DeviceGraphics_supportGLExtension : 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_gfx_DeviceGraphics_supportGLExtension)
|
|
|
|
static bool js_gfx_DeviceGraphics_setStencilOp(se::State& s)
|
|
{
|
|
cocos2d::renderer::DeviceGraphics* cobj = (cocos2d::renderer::DeviceGraphics*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_DeviceGraphics_setStencilOp : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 4) {
|
|
cocos2d::renderer::StencilOp arg0;
|
|
cocos2d::renderer::StencilOp arg1;
|
|
cocos2d::renderer::StencilOp arg2;
|
|
unsigned int arg3 = 0;
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[0], &tmp); arg0 = (cocos2d::renderer::StencilOp)tmp; } while(false);
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[1], &tmp); arg1 = (cocos2d::renderer::StencilOp)tmp; } while(false);
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[2], &tmp); arg2 = (cocos2d::renderer::StencilOp)tmp; } while(false);
|
|
ok &= seval_to_uint32(args[3], (uint32_t*)&arg3);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_DeviceGraphics_setStencilOp : Error processing arguments");
|
|
cobj->setStencilOp(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_gfx_DeviceGraphics_setStencilOp)
|
|
|
|
static bool js_gfx_DeviceGraphics_enableStencilTest(se::State& s)
|
|
{
|
|
cocos2d::renderer::DeviceGraphics* cobj = (cocos2d::renderer::DeviceGraphics*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_DeviceGraphics_enableStencilTest : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
if (argc == 0) {
|
|
cobj->enableStencilTest();
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_DeviceGraphics_enableStencilTest)
|
|
|
|
static bool js_gfx_DeviceGraphics_getInstance(se::State& s)
|
|
{
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 0) {
|
|
auto result = cocos2d::renderer::DeviceGraphics::getInstance();
|
|
se::Value instanceVal;
|
|
native_ptr_to_seval<cocos2d::renderer::DeviceGraphics>(result, __jsb_cocos2d_renderer_DeviceGraphics_class, &instanceVal);
|
|
instanceVal.toObject()->root();
|
|
s.rval() = instanceVal;
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_DeviceGraphics_getInstance)
|
|
|
|
|
|
|
|
|
|
bool js_register_gfx_DeviceGraphics(se::Object* obj)
|
|
{
|
|
auto cls = se::Class::create("Device", obj, nullptr, nullptr);
|
|
|
|
cls->defineFunction("setTexture", _SE(js_gfx_DeviceGraphics_setTexture));
|
|
cls->defineFunction("setBlendFuncSep", _SE(js_gfx_DeviceGraphics_setBlendFuncSeparate));
|
|
cls->defineFunction("enableBlend", _SE(js_gfx_DeviceGraphics_enableBlend));
|
|
cls->defineFunction("setPrimitiveType", _SE(js_gfx_DeviceGraphics_setPrimitiveType));
|
|
cls->defineFunction("setBlendEqSep", _SE(js_gfx_DeviceGraphics_setBlendEquationSeparate));
|
|
cls->defineFunction("setIndexBuffer", _SE(js_gfx_DeviceGraphics_setIndexBuffer));
|
|
cls->defineFunction("setProgram", _SE(js_gfx_DeviceGraphics_setProgram));
|
|
cls->defineFunction("setFrameBuffer", _SE(js_gfx_DeviceGraphics_setFrameBuffer));
|
|
cls->defineFunction("setStencilFunc", _SE(js_gfx_DeviceGraphics_setStencilFunc));
|
|
cls->defineFunction("setBlendColor", _SE(js_gfx_DeviceGraphics_setBlendColor));
|
|
cls->defineFunction("setScissor", _SE(js_gfx_DeviceGraphics_setScissor));
|
|
cls->defineFunction("setVertexBuffer", _SE(js_gfx_DeviceGraphics_setVertexBuffer));
|
|
cls->defineFunction("enableDepthWrite", _SE(js_gfx_DeviceGraphics_enableDepthWrite));
|
|
cls->defineFunction("setTextureArray", _SE(js_gfx_DeviceGraphics_setTextureArray));
|
|
cls->defineFunction("getCapacity", _SE(js_gfx_DeviceGraphics_getCapacity));
|
|
cls->defineFunction("setStencilOpBack", _SE(js_gfx_DeviceGraphics_setStencilOpBack));
|
|
cls->defineFunction("setViewport", _SE(js_gfx_DeviceGraphics_setViewport));
|
|
cls->defineFunction("draw", _SE(js_gfx_DeviceGraphics_draw));
|
|
cls->defineFunction("setDepthFunc", _SE(js_gfx_DeviceGraphics_setDepthFunc));
|
|
cls->defineFunction("enableDepthTest", _SE(js_gfx_DeviceGraphics_enableDepthTest));
|
|
cls->defineFunction("setBlendEquation", _SE(js_gfx_DeviceGraphics_setBlendEquation));
|
|
cls->defineFunction("setStencilFuncFront", _SE(js_gfx_DeviceGraphics_setStencilFuncFront));
|
|
cls->defineFunction("setStencilOpFront", _SE(js_gfx_DeviceGraphics_setStencilOpFront));
|
|
cls->defineFunction("setStencilFuncBack", _SE(js_gfx_DeviceGraphics_setStencilFuncBack));
|
|
cls->defineFunction("setBlendFunc", _SE(js_gfx_DeviceGraphics_setBlendFunc));
|
|
cls->defineFunction("setCullMode", _SE(js_gfx_DeviceGraphics_setCullMode));
|
|
cls->defineFunction("supportGLExtension", _SE(js_gfx_DeviceGraphics_supportGLExtension));
|
|
cls->defineFunction("setStencilOp", _SE(js_gfx_DeviceGraphics_setStencilOp));
|
|
cls->defineFunction("enableStencilTest", _SE(js_gfx_DeviceGraphics_enableStencilTest));
|
|
cls->defineStaticFunction("getInstance", _SE(js_gfx_DeviceGraphics_getInstance));
|
|
cls->install();
|
|
JSBClassType::registerClass<cocos2d::renderer::DeviceGraphics>(cls);
|
|
|
|
__jsb_cocos2d_renderer_DeviceGraphics_proto = cls->getProto();
|
|
__jsb_cocos2d_renderer_DeviceGraphics_class = cls;
|
|
|
|
se::ScriptEngine::getInstance()->clearException();
|
|
return true;
|
|
}
|
|
|
|
se::Object* __jsb_cocos2d_renderer_FrameBuffer_proto = nullptr;
|
|
se::Class* __jsb_cocos2d_renderer_FrameBuffer_class = nullptr;
|
|
|
|
static bool js_gfx_FrameBuffer_destroy(se::State& s)
|
|
{
|
|
cocos2d::renderer::FrameBuffer* cobj = (cocos2d::renderer::FrameBuffer*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_FrameBuffer_destroy : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
if (argc == 0) {
|
|
cobj->destroy();
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_FrameBuffer_destroy)
|
|
|
|
SE_DECLARE_FINALIZE_FUNC(js_cocos2d_renderer_FrameBuffer_finalize)
|
|
|
|
static bool js_gfx_FrameBuffer_constructor(se::State& s)
|
|
{
|
|
cocos2d::renderer::FrameBuffer* cobj = new (std::nothrow) cocos2d::renderer::FrameBuffer();
|
|
s.thisObject()->setPrivateData(cobj);
|
|
return true;
|
|
}
|
|
SE_BIND_CTOR(js_gfx_FrameBuffer_constructor, __jsb_cocos2d_renderer_FrameBuffer_class, js_cocos2d_renderer_FrameBuffer_finalize)
|
|
|
|
|
|
|
|
extern se::Object* __jsb_cocos2d_renderer_GraphicsHandle_proto;
|
|
|
|
static bool js_cocos2d_renderer_FrameBuffer_finalize(se::State& s)
|
|
{
|
|
CCLOGINFO("jsbindings: finalizing JS object %p (cocos2d::renderer::FrameBuffer)", s.nativeThisObject());
|
|
cocos2d::renderer::FrameBuffer* cobj = (cocos2d::renderer::FrameBuffer*)s.nativeThisObject();
|
|
cobj->release();
|
|
return true;
|
|
}
|
|
SE_BIND_FINALIZE_FUNC(js_cocos2d_renderer_FrameBuffer_finalize)
|
|
|
|
bool js_register_gfx_FrameBuffer(se::Object* obj)
|
|
{
|
|
auto cls = se::Class::create("FrameBuffer", obj, __jsb_cocos2d_renderer_GraphicsHandle_proto, _SE(js_gfx_FrameBuffer_constructor));
|
|
|
|
cls->defineFunction("destroy", _SE(js_gfx_FrameBuffer_destroy));
|
|
cls->defineFinalizeFunction(_SE(js_cocos2d_renderer_FrameBuffer_finalize));
|
|
cls->install();
|
|
JSBClassType::registerClass<cocos2d::renderer::FrameBuffer>(cls);
|
|
|
|
__jsb_cocos2d_renderer_FrameBuffer_proto = cls->getProto();
|
|
__jsb_cocos2d_renderer_FrameBuffer_class = cls;
|
|
|
|
se::ScriptEngine::getInstance()->clearException();
|
|
return true;
|
|
}
|
|
|
|
se::Object* __jsb_cocos2d_renderer_RenderTarget_proto = nullptr;
|
|
se::Class* __jsb_cocos2d_renderer_RenderTarget_class = nullptr;
|
|
|
|
|
|
extern se::Object* __jsb_cocos2d_renderer_GraphicsHandle_proto;
|
|
|
|
static bool js_cocos2d_renderer_RenderTarget_finalize(se::State& s)
|
|
{
|
|
CCLOGINFO("jsbindings: finalizing JS object %p (cocos2d::renderer::RenderTarget)", s.nativeThisObject());
|
|
cocos2d::renderer::RenderTarget* cobj = (cocos2d::renderer::RenderTarget*)s.nativeThisObject();
|
|
cobj->release();
|
|
return true;
|
|
}
|
|
SE_BIND_FINALIZE_FUNC(js_cocos2d_renderer_RenderTarget_finalize)
|
|
|
|
bool js_register_gfx_RenderTarget(se::Object* obj)
|
|
{
|
|
auto cls = se::Class::create("RenderTarget", obj, __jsb_cocos2d_renderer_GraphicsHandle_proto, nullptr);
|
|
|
|
cls->defineFinalizeFunction(_SE(js_cocos2d_renderer_RenderTarget_finalize));
|
|
cls->install();
|
|
JSBClassType::registerClass<cocos2d::renderer::RenderTarget>(cls);
|
|
|
|
__jsb_cocos2d_renderer_RenderTarget_proto = cls->getProto();
|
|
__jsb_cocos2d_renderer_RenderTarget_class = cls;
|
|
|
|
se::ScriptEngine::getInstance()->clearException();
|
|
return true;
|
|
}
|
|
|
|
se::Object* __jsb_cocos2d_renderer_RenderBuffer_proto = nullptr;
|
|
se::Class* __jsb_cocos2d_renderer_RenderBuffer_class = nullptr;
|
|
|
|
static bool js_gfx_RenderBuffer_init(se::State& s)
|
|
{
|
|
cocos2d::renderer::RenderBuffer* cobj = (cocos2d::renderer::RenderBuffer*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_RenderBuffer_init : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 4) {
|
|
cocos2d::renderer::DeviceGraphics* arg0 = nullptr;
|
|
cocos2d::renderer::RenderBuffer::Format arg1;
|
|
unsigned short arg2 = 0;
|
|
unsigned short arg3 = 0;
|
|
ok &= seval_to_native_ptr(args[0], &arg0);
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[1], &tmp); arg1 = (cocos2d::renderer::RenderBuffer::Format)tmp; } while(false);
|
|
ok &= seval_to_uint16(args[2], &arg2);
|
|
ok &= seval_to_uint16(args[3], &arg3);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_RenderBuffer_init : Error processing arguments");
|
|
bool result = cobj->init(arg0, arg1, arg2, arg3);
|
|
ok &= boolean_to_seval(result, &s.rval());
|
|
SE_PRECONDITION2(ok, false, "js_gfx_RenderBuffer_init : 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_gfx_RenderBuffer_init)
|
|
|
|
static bool js_gfx_RenderBuffer_create(se::State& s)
|
|
{
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 4) {
|
|
cocos2d::renderer::DeviceGraphics* arg0 = nullptr;
|
|
cocos2d::renderer::RenderBuffer::Format arg1;
|
|
unsigned short arg2 = 0;
|
|
unsigned short arg3 = 0;
|
|
ok &= seval_to_native_ptr(args[0], &arg0);
|
|
do { int32_t tmp = 0; ok &= seval_to_int32(args[1], &tmp); arg1 = (cocos2d::renderer::RenderBuffer::Format)tmp; } while(false);
|
|
ok &= seval_to_uint16(args[2], &arg2);
|
|
ok &= seval_to_uint16(args[3], &arg3);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_RenderBuffer_create : Error processing arguments");
|
|
auto result = cocos2d::renderer::RenderBuffer::create(arg0, arg1, arg2, arg3);
|
|
result->retain();
|
|
auto obj = se::Object::createObjectWithClass(__jsb_cocos2d_renderer_RenderBuffer_class);
|
|
obj->setPrivateData(result);
|
|
s.rval().setObject(obj);
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_RenderBuffer_create)
|
|
|
|
SE_DECLARE_FINALIZE_FUNC(js_cocos2d_renderer_RenderBuffer_finalize)
|
|
|
|
static bool js_gfx_RenderBuffer_constructor(se::State& s)
|
|
{
|
|
cocos2d::renderer::RenderBuffer* cobj = new (std::nothrow) cocos2d::renderer::RenderBuffer();
|
|
s.thisObject()->setPrivateData(cobj);
|
|
return true;
|
|
}
|
|
SE_BIND_CTOR(js_gfx_RenderBuffer_constructor, __jsb_cocos2d_renderer_RenderBuffer_class, js_cocos2d_renderer_RenderBuffer_finalize)
|
|
|
|
|
|
|
|
extern se::Object* __jsb_cocos2d_renderer_RenderTarget_proto;
|
|
|
|
static bool js_cocos2d_renderer_RenderBuffer_finalize(se::State& s)
|
|
{
|
|
CCLOGINFO("jsbindings: finalizing JS object %p (cocos2d::renderer::RenderBuffer)", s.nativeThisObject());
|
|
cocos2d::renderer::RenderBuffer* cobj = (cocos2d::renderer::RenderBuffer*)s.nativeThisObject();
|
|
cobj->release();
|
|
return true;
|
|
}
|
|
SE_BIND_FINALIZE_FUNC(js_cocos2d_renderer_RenderBuffer_finalize)
|
|
|
|
bool js_register_gfx_RenderBuffer(se::Object* obj)
|
|
{
|
|
auto cls = se::Class::create("RenderBuffer", obj, __jsb_cocos2d_renderer_RenderTarget_proto, _SE(js_gfx_RenderBuffer_constructor));
|
|
|
|
cls->defineFunction("init", _SE(js_gfx_RenderBuffer_init));
|
|
cls->defineStaticFunction("create", _SE(js_gfx_RenderBuffer_create));
|
|
cls->defineFinalizeFunction(_SE(js_cocos2d_renderer_RenderBuffer_finalize));
|
|
cls->install();
|
|
JSBClassType::registerClass<cocos2d::renderer::RenderBuffer>(cls);
|
|
|
|
__jsb_cocos2d_renderer_RenderBuffer_proto = cls->getProto();
|
|
__jsb_cocos2d_renderer_RenderBuffer_class = cls;
|
|
|
|
se::ScriptEngine::getInstance()->clearException();
|
|
return true;
|
|
}
|
|
|
|
se::Object* __jsb_cocos2d_renderer_Texture_proto = nullptr;
|
|
se::Class* __jsb_cocos2d_renderer_Texture_class = nullptr;
|
|
|
|
static bool js_gfx_Texture_getWidth(se::State& s)
|
|
{
|
|
cocos2d::renderer::Texture* cobj = (cocos2d::renderer::Texture*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_Texture_getWidth : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 0) {
|
|
unsigned short result = cobj->getWidth();
|
|
ok &= int16_to_seval(result, &s.rval());
|
|
SE_PRECONDITION2(ok, false, "js_gfx_Texture_getWidth : 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_gfx_Texture_getWidth)
|
|
|
|
static bool js_gfx_Texture_getHeight(se::State& s)
|
|
{
|
|
cocos2d::renderer::Texture* cobj = (cocos2d::renderer::Texture*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_Texture_getHeight : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 0) {
|
|
unsigned short result = cobj->getHeight();
|
|
ok &= int16_to_seval(result, &s.rval());
|
|
SE_PRECONDITION2(ok, false, "js_gfx_Texture_getHeight : 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_gfx_Texture_getHeight)
|
|
|
|
static bool js_gfx_Texture_getTarget(se::State& s)
|
|
{
|
|
cocos2d::renderer::Texture* cobj = (cocos2d::renderer::Texture*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_Texture_getTarget : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 0) {
|
|
unsigned int result = cobj->getTarget();
|
|
ok &= uint32_to_seval(result, &s.rval());
|
|
SE_PRECONDITION2(ok, false, "js_gfx_Texture_getTarget : 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_gfx_Texture_getTarget)
|
|
|
|
|
|
extern se::Object* __jsb_cocos2d_renderer_RenderTarget_proto;
|
|
|
|
static bool js_cocos2d_renderer_Texture_finalize(se::State& s)
|
|
{
|
|
CCLOGINFO("jsbindings: finalizing JS object %p (cocos2d::renderer::Texture)", s.nativeThisObject());
|
|
cocos2d::renderer::Texture* cobj = (cocos2d::renderer::Texture*)s.nativeThisObject();
|
|
cobj->release();
|
|
return true;
|
|
}
|
|
SE_BIND_FINALIZE_FUNC(js_cocos2d_renderer_Texture_finalize)
|
|
|
|
bool js_register_gfx_Texture(se::Object* obj)
|
|
{
|
|
auto cls = se::Class::create("Texture", obj, __jsb_cocos2d_renderer_RenderTarget_proto, nullptr);
|
|
|
|
cls->defineFunction("getWidth", _SE(js_gfx_Texture_getWidth));
|
|
cls->defineFunction("getHeight", _SE(js_gfx_Texture_getHeight));
|
|
cls->defineFunction("getTarget", _SE(js_gfx_Texture_getTarget));
|
|
cls->defineFinalizeFunction(_SE(js_cocos2d_renderer_Texture_finalize));
|
|
cls->install();
|
|
JSBClassType::registerClass<cocos2d::renderer::Texture>(cls);
|
|
|
|
__jsb_cocos2d_renderer_Texture_proto = cls->getProto();
|
|
__jsb_cocos2d_renderer_Texture_class = cls;
|
|
|
|
se::ScriptEngine::getInstance()->clearException();
|
|
return true;
|
|
}
|
|
|
|
se::Object* __jsb_cocos2d_renderer_Texture2D_proto = nullptr;
|
|
se::Class* __jsb_cocos2d_renderer_Texture2D_class = nullptr;
|
|
|
|
static bool js_gfx_Texture2D_updateImage(se::State& s)
|
|
{
|
|
cocos2d::renderer::Texture2D* cobj = (cocos2d::renderer::Texture2D*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_Texture2D_updateImage : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 1) {
|
|
cocos2d::renderer::Texture::ImageOption arg0;
|
|
ok &= seval_to_TextureImageOption(args[0], &arg0);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_Texture2D_updateImage : Error processing arguments");
|
|
cobj->updateImage(arg0);
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_Texture2D_updateImage)
|
|
|
|
static bool js_gfx_Texture2D_init(se::State& s)
|
|
{
|
|
cocos2d::renderer::Texture2D* cobj = (cocos2d::renderer::Texture2D*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_Texture2D_init : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 2) {
|
|
cocos2d::renderer::DeviceGraphics* arg0 = nullptr;
|
|
cocos2d::renderer::Texture::Options arg1;
|
|
ok &= seval_to_native_ptr(args[0], &arg0);
|
|
ok &= seval_to_TextureOptions(args[1], &arg1);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_Texture2D_init : Error processing arguments");
|
|
bool result = cobj->init(arg0, arg1);
|
|
ok &= boolean_to_seval(result, &s.rval());
|
|
SE_PRECONDITION2(ok, false, "js_gfx_Texture2D_init : 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_gfx_Texture2D_init)
|
|
|
|
static bool js_gfx_Texture2D_updateSubImage(se::State& s)
|
|
{
|
|
cocos2d::renderer::Texture2D* cobj = (cocos2d::renderer::Texture2D*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_Texture2D_updateSubImage : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 1) {
|
|
cocos2d::renderer::Texture::SubImageOption arg0;
|
|
ok &= seval_to_TextureSubImageOption(args[0], &arg0);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_Texture2D_updateSubImage : Error processing arguments");
|
|
cobj->updateSubImage(arg0);
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_Texture2D_updateSubImage)
|
|
|
|
static bool js_gfx_Texture2D_update(se::State& s)
|
|
{
|
|
cocos2d::renderer::Texture2D* cobj = (cocos2d::renderer::Texture2D*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_Texture2D_update : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 1) {
|
|
cocos2d::renderer::Texture::Options arg0;
|
|
ok &= seval_to_TextureOptions(args[0], &arg0);
|
|
SE_PRECONDITION2(ok, false, "js_gfx_Texture2D_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_gfx_Texture2D_update)
|
|
|
|
SE_DECLARE_FINALIZE_FUNC(js_cocos2d_renderer_Texture2D_finalize)
|
|
|
|
static bool js_gfx_Texture2D_constructor(se::State& s)
|
|
{
|
|
cocos2d::renderer::Texture2D* cobj = new (std::nothrow) cocos2d::renderer::Texture2D();
|
|
s.thisObject()->setPrivateData(cobj);
|
|
return true;
|
|
}
|
|
SE_BIND_CTOR(js_gfx_Texture2D_constructor, __jsb_cocos2d_renderer_Texture2D_class, js_cocos2d_renderer_Texture2D_finalize)
|
|
|
|
|
|
|
|
extern se::Object* __jsb_cocos2d_renderer_Texture_proto;
|
|
|
|
static bool js_cocos2d_renderer_Texture2D_finalize(se::State& s)
|
|
{
|
|
CCLOGINFO("jsbindings: finalizing JS object %p (cocos2d::renderer::Texture2D)", s.nativeThisObject());
|
|
cocos2d::renderer::Texture2D* cobj = (cocos2d::renderer::Texture2D*)s.nativeThisObject();
|
|
cobj->release();
|
|
return true;
|
|
}
|
|
SE_BIND_FINALIZE_FUNC(js_cocos2d_renderer_Texture2D_finalize)
|
|
|
|
bool js_register_gfx_Texture2D(se::Object* obj)
|
|
{
|
|
auto cls = se::Class::create("Texture2D", obj, __jsb_cocos2d_renderer_Texture_proto, _SE(js_gfx_Texture2D_constructor));
|
|
|
|
cls->defineFunction("updateImage", _SE(js_gfx_Texture2D_updateImage));
|
|
cls->defineFunction("init", _SE(js_gfx_Texture2D_init));
|
|
cls->defineFunction("updateSubImageNative", _SE(js_gfx_Texture2D_updateSubImage));
|
|
cls->defineFunction("updateNative", _SE(js_gfx_Texture2D_update));
|
|
cls->defineFinalizeFunction(_SE(js_cocos2d_renderer_Texture2D_finalize));
|
|
cls->install();
|
|
JSBClassType::registerClass<cocos2d::renderer::Texture2D>(cls);
|
|
|
|
__jsb_cocos2d_renderer_Texture2D_proto = cls->getProto();
|
|
__jsb_cocos2d_renderer_Texture2D_class = cls;
|
|
|
|
se::ScriptEngine::getInstance()->clearException();
|
|
return true;
|
|
}
|
|
|
|
se::Object* __jsb_cocos2d_renderer_Program_proto = nullptr;
|
|
se::Class* __jsb_cocos2d_renderer_Program_class = nullptr;
|
|
|
|
static bool js_gfx_Program_getID(se::State& s)
|
|
{
|
|
cocos2d::renderer::Program* cobj = (cocos2d::renderer::Program*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_Program_getID : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 0) {
|
|
unsigned int result = cobj->getID();
|
|
ok &= uint32_to_seval(result, &s.rval());
|
|
SE_PRECONDITION2(ok, false, "js_gfx_Program_getID : 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_gfx_Program_getID)
|
|
|
|
static bool js_gfx_Program_init(se::State& s)
|
|
{
|
|
cocos2d::renderer::Program* cobj = (cocos2d::renderer::Program*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_Program_init : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
CC_UNUSED bool ok = true;
|
|
if (argc == 3) {
|
|
cocos2d::renderer::DeviceGraphics* arg0 = nullptr;
|
|
const char* arg1 = nullptr;
|
|
const char* arg2 = nullptr;
|
|
ok &= seval_to_native_ptr(args[0], &arg0);
|
|
std::string arg1_tmp; ok &= seval_to_std_string(args[1], &arg1_tmp); arg1 = arg1_tmp.c_str();
|
|
std::string arg2_tmp; ok &= seval_to_std_string(args[2], &arg2_tmp); arg2 = arg2_tmp.c_str();
|
|
SE_PRECONDITION2(ok, false, "js_gfx_Program_init : Error processing arguments");
|
|
bool result = cobj->init(arg0, arg1, arg2);
|
|
ok &= boolean_to_seval(result, &s.rval());
|
|
SE_PRECONDITION2(ok, false, "js_gfx_Program_init : Error processing arguments");
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_Program_init)
|
|
|
|
static bool js_gfx_Program_link(se::State& s)
|
|
{
|
|
cocos2d::renderer::Program* cobj = (cocos2d::renderer::Program*)s.nativeThisObject();
|
|
SE_PRECONDITION2(cobj, false, "js_gfx_Program_link : Invalid Native Object");
|
|
const auto& args = s.args();
|
|
size_t argc = args.size();
|
|
if (argc == 0) {
|
|
cobj->link();
|
|
return true;
|
|
}
|
|
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
|
|
return false;
|
|
}
|
|
SE_BIND_FUNC(js_gfx_Program_link)
|
|
|
|
SE_DECLARE_FINALIZE_FUNC(js_cocos2d_renderer_Program_finalize)
|
|
|
|
static bool js_gfx_Program_constructor(se::State& s)
|
|
{
|
|
cocos2d::renderer::Program* cobj = new (std::nothrow) cocos2d::renderer::Program();
|
|
s.thisObject()->setPrivateData(cobj);
|
|
return true;
|
|
}
|
|
SE_BIND_CTOR(js_gfx_Program_constructor, __jsb_cocos2d_renderer_Program_class, js_cocos2d_renderer_Program_finalize)
|
|
|
|
|
|
|
|
extern se::Object* __jsb_cocos2d_renderer_GraphicsHandle_proto;
|
|
|
|
static bool js_cocos2d_renderer_Program_finalize(se::State& s)
|
|
{
|
|
CCLOGINFO("jsbindings: finalizing JS object %p (cocos2d::renderer::Program)", s.nativeThisObject());
|
|
cocos2d::renderer::Program* cobj = (cocos2d::renderer::Program*)s.nativeThisObject();
|
|
cobj->release();
|
|
return true;
|
|
}
|
|
SE_BIND_FINALIZE_FUNC(js_cocos2d_renderer_Program_finalize)
|
|
|
|
bool js_register_gfx_Program(se::Object* obj)
|
|
{
|
|
auto cls = se::Class::create("Program", obj, __jsb_cocos2d_renderer_GraphicsHandle_proto, _SE(js_gfx_Program_constructor));
|
|
|
|
cls->defineFunction("getID", _SE(js_gfx_Program_getID));
|
|
cls->defineFunction("init", _SE(js_gfx_Program_init));
|
|
cls->defineFunction("link", _SE(js_gfx_Program_link));
|
|
cls->defineFinalizeFunction(_SE(js_cocos2d_renderer_Program_finalize));
|
|
cls->install();
|
|
JSBClassType::registerClass<cocos2d::renderer::Program>(cls);
|
|
|
|
__jsb_cocos2d_renderer_Program_proto = cls->getProto();
|
|
__jsb_cocos2d_renderer_Program_class = cls;
|
|
|
|
se::ScriptEngine::getInstance()->clearException();
|
|
return true;
|
|
}
|
|
|
|
bool register_all_gfx(se::Object* obj)
|
|
{
|
|
// Get the ns
|
|
se::Value nsVal;
|
|
if (!obj->getProperty("gfx", &nsVal))
|
|
{
|
|
se::HandleObject jsobj(se::Object::createPlainObject());
|
|
nsVal.setObject(jsobj);
|
|
obj->setProperty("gfx", nsVal);
|
|
}
|
|
se::Object* ns = nsVal.toObject();
|
|
|
|
js_register_gfx_GraphicsHandle(ns);
|
|
js_register_gfx_RenderTarget(ns);
|
|
js_register_gfx_RenderBuffer(ns);
|
|
js_register_gfx_VertexBuffer(ns);
|
|
js_register_gfx_DeviceGraphics(ns);
|
|
js_register_gfx_Texture(ns);
|
|
js_register_gfx_Program(ns);
|
|
js_register_gfx_Texture2D(ns);
|
|
js_register_gfx_IndexBuffer(ns);
|
|
js_register_gfx_FrameBuffer(ns);
|
|
return true;
|
|
}
|
|
|
|
#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)
|