mirror of
https://github.com/cocos/cocos4.git
synced 2026-11-20 23:52:40 +08:00
Merge branch 'new-renderer' of git://github.com/cocos-creator/cocos2d-x-lite into runtime
# Conflicts: # cocos/platform/mac/CCCanvasRenderingContext2D-mac.mm # cocos/scripting/js-bindings/manual/jsb_gfx_manual.cpp
This commit is contained in:
@@ -178,7 +178,7 @@ namespace {
|
||||
|
||||
-(NSPoint) convertDrawPoint:(NSPoint) point text:(NSString*) text {
|
||||
NSSize textSize = [self measureText:text];
|
||||
NSLog(@"textSize: %f, %f", textSize.width, textSize.height);
|
||||
// NSLog(@"textSize: %f, %f", textSize.width, textSize.height);
|
||||
|
||||
if (_textAlign == CanvasTextAlign::CENTER)
|
||||
{
|
||||
@@ -277,7 +277,7 @@ namespace {
|
||||
return;
|
||||
//TODO:
|
||||
assert(rect.origin.x == 0 && rect.origin.y == 0);
|
||||
NSLog(@"clearRect, image:%f, %f", _image.size.width, _image.size.height);
|
||||
// NSLog(@"clearRect, image:%f, %f", _image.size.width, _image.size.height);
|
||||
assert(rect.size.width <= _image.size.width && rect.size.height <= _image.size.height);
|
||||
|
||||
[_image lockFocus];
|
||||
@@ -329,7 +329,7 @@ CanvasRenderingContext2D::CanvasRenderingContext2D(float width, float height)
|
||||
: __width(width)
|
||||
, __height(height)
|
||||
{
|
||||
SE_LOGD("CanvasRenderingContext2D constructor: %p, width: %f, height: %f\n", this, width, height);
|
||||
SE_LOGD("CanvasGradient constructor: %p, width: %f, height: %f\n", this, width, height);
|
||||
_impl = [[CanvasRenderingContext2DImpl alloc] init];
|
||||
[_impl recreateBufferWithWidth:width height:height];
|
||||
}
|
||||
@@ -348,7 +348,7 @@ void CanvasRenderingContext2D::recreateBuffer()
|
||||
|
||||
void CanvasRenderingContext2D::clearRect(float x, float y, float width, float height)
|
||||
{
|
||||
SE_LOGD("CanvasGradient::clearRect: %p, %f, %f, %f, %f\n", this, x, y, width, height);
|
||||
// SE_LOGD("CanvasGradient::clearRect: %p, %f, %f, %f, %f\n", this, x, y, width, height);
|
||||
[_impl clearRect:CGRectMake(x, y, width, height)];
|
||||
}
|
||||
|
||||
@@ -364,7 +364,7 @@ void CanvasRenderingContext2D::fillRect(float x, float y, float width, float hei
|
||||
|
||||
void CanvasRenderingContext2D::fillText(const std::string& text, float x, float y, float maxWidth)
|
||||
{
|
||||
SE_LOGD("CanvasRenderingContext2D::fillText: %s, %f, %f, %f\n", text.c_str(), x, y, maxWidth);
|
||||
// SE_LOGD("CanvasRenderingContext2D::fillText: %s, %f, %f, %f\n", text.c_str(), x, y, maxWidth);
|
||||
if (text.empty())
|
||||
return;
|
||||
if (_isBufferSizeDirty)
|
||||
@@ -377,7 +377,7 @@ void CanvasRenderingContext2D::fillText(const std::string& text, float x, float
|
||||
|
||||
void CanvasRenderingContext2D::strokeText(const std::string& text, float x, float y, float maxWidth)
|
||||
{
|
||||
SE_LOGD("CanvasRenderingContext2D::strokeText: %s, %f, %f, %f\n", text.c_str(), x, y, maxWidth);
|
||||
// SE_LOGD("CanvasRenderingContext2D::strokeText: %s, %f, %f, %f\n", text.c_str(), x, y, maxWidth);
|
||||
if (text.empty())
|
||||
return;
|
||||
if (_isBufferSizeDirty)
|
||||
@@ -389,7 +389,7 @@ void CanvasRenderingContext2D::strokeText(const std::string& text, float x, floa
|
||||
|
||||
cocos2d::Size CanvasRenderingContext2D::measureText(const std::string& text)
|
||||
{
|
||||
SE_LOGD("CanvasRenderingContext2D::measureText: %s\n", text.c_str());
|
||||
// SE_LOGD("CanvasRenderingContext2D::measureText: %s\n", text.c_str());
|
||||
CGSize size = [_impl measureText: [NSString stringWithUTF8String:text.c_str()]];
|
||||
return cocos2d::Size(size.width, size.height);
|
||||
}
|
||||
@@ -441,7 +441,7 @@ void CanvasRenderingContext2D::setCanvasBufferUpdatedCallback(const CanvasBuffer
|
||||
|
||||
void CanvasRenderingContext2D::set__width(float width)
|
||||
{
|
||||
SE_LOGD("CanvasRenderingContext2D::set__width: %f\n", width);
|
||||
// SE_LOGD("CanvasRenderingContext2D::set__width: %f\n", width);
|
||||
__width = width;
|
||||
_isBufferSizeDirty = true;
|
||||
recreateBuffer();
|
||||
@@ -449,7 +449,7 @@ void CanvasRenderingContext2D::set__width(float width)
|
||||
|
||||
void CanvasRenderingContext2D::set__height(float height)
|
||||
{
|
||||
SE_LOGD("CanvasRenderingContext2D::set__height: %f\n", height);
|
||||
// SE_LOGD("CanvasRenderingContext2D::set__height: %f\n", height);
|
||||
__height = height;
|
||||
_isBufferSizeDirty = true;
|
||||
recreateBuffer();
|
||||
@@ -492,7 +492,7 @@ void CanvasRenderingContext2D::set_font(const std::string& font)
|
||||
|
||||
void CanvasRenderingContext2D::set_textAlign(const std::string& textAlign)
|
||||
{
|
||||
SE_LOGD("CanvasRenderingContext2D::set_textAlign: %s\n", textAlign.c_str());
|
||||
// SE_LOGD("CanvasRenderingContext2D::set_textAlign: %s\n", textAlign.c_str());
|
||||
if (textAlign == "left")
|
||||
{
|
||||
_impl.textAlign = CanvasTextAlign::LEFT;
|
||||
@@ -513,7 +513,7 @@ void CanvasRenderingContext2D::set_textAlign(const std::string& textAlign)
|
||||
|
||||
void CanvasRenderingContext2D::set_textBaseline(const std::string& textBaseline)
|
||||
{
|
||||
SE_LOGD("CanvasRenderingContext2D::set_textBaseline: %s\n", textBaseline.c_str());
|
||||
// SE_LOGD("CanvasRenderingContext2D::set_textBaseline: %s\n", textBaseline.c_str());
|
||||
if (textBaseline == "top")
|
||||
{
|
||||
_impl.textBaseLine = CanvasTextBaseline::TOP;
|
||||
@@ -536,7 +536,7 @@ void CanvasRenderingContext2D::set_fillStyle(const std::string& fillStyle)
|
||||
{
|
||||
CSSColorParser::Color color = CSSColorParser::parse(fillStyle);
|
||||
[_impl setFillStyleWithRed:color.r/255.0f green:color.g/255.0f blue:color.b/255.0f alpha:color.a];
|
||||
SE_LOGD("CanvasRenderingContext2D::set_fillStyle: %s, (%d, %d, %d, %f)\n", fillStyle.c_str(), color.r, color.g, color.b, color.a);
|
||||
// SE_LOGD("CanvasRenderingContext2D::set_fillStyle: %s, (%d, %d, %d, %f)\n", fillStyle.c_str(), color.r, color.g, color.b, color.a);
|
||||
}
|
||||
|
||||
void CanvasRenderingContext2D::set_strokeStyle(const std::string& strokeStyle)
|
||||
|
||||
@@ -504,12 +504,12 @@ RENDERER_BEGIN
|
||||
|
||||
Texture2D::Texture2D()
|
||||
{
|
||||
RENDERER_LOGD("Construct Texture2D: %p", this);
|
||||
// RENDERER_LOGD("Construct Texture2D: %p", this);
|
||||
}
|
||||
|
||||
Texture2D::~Texture2D()
|
||||
{
|
||||
RENDERER_LOGD("Destruct Texture2D: %p", this);
|
||||
// RENDERER_LOGD("Destruct Texture2D: %p", this);
|
||||
}
|
||||
|
||||
bool Texture2D::init(DeviceGraphics* device, const Options& options)
|
||||
@@ -522,7 +522,14 @@ bool Texture2D::init(DeviceGraphics* device, const Options& options)
|
||||
|
||||
if (options.images.empty())
|
||||
{
|
||||
const_cast<Options&>(options).images.push_back(Data());
|
||||
const auto& glFmt = glTextureFmt(_format);
|
||||
int len = options.width * options.height * glFmt.bpp / 8;
|
||||
unsigned char* tmpData = new unsigned char[len];
|
||||
memset(tmpData, 255, len);
|
||||
Data data;
|
||||
data.copy(tmpData, len);
|
||||
delete [] tmpData;
|
||||
const_cast<Options&>(options).images.push_back(data);
|
||||
}
|
||||
|
||||
update(options);
|
||||
@@ -654,7 +661,7 @@ void Texture2D::setImage(const GLTextureFmt& glFmt, const ImageOption& option)
|
||||
|
||||
//Set the row align only when mipmapsNum == 1 and the data is uncompressed
|
||||
GLint aligment = 1;
|
||||
if (!_hasMipmap && !_compressed && glFmt.bpp > 0)
|
||||
if (_hasMipmap && !_compressed && glFmt.bpp > 0)
|
||||
{
|
||||
unsigned int bytesPerRow = option.width * glFmt.bpp / 8;
|
||||
|
||||
|
||||
@@ -66,6 +66,7 @@ public:
|
||||
virtual ~BaseRenderer();
|
||||
|
||||
void registerStage(const std::string& name, const StageCallback& callback);
|
||||
ProgramLib* getProgramLib() const { return _programLib; }
|
||||
|
||||
protected:
|
||||
void render(const View*, const Scene* scene);
|
||||
|
||||
@@ -34,12 +34,12 @@ Effect::Effect(const Vector<Technique*>& techniques,
|
||||
, _properties(properties)
|
||||
, _defineTemplates(defineTemplates)
|
||||
{
|
||||
RENDERER_LOGD("Effect construction: %p", this);
|
||||
// RENDERER_LOGD("Effect construction: %p", this);
|
||||
}
|
||||
|
||||
Effect::~Effect()
|
||||
{
|
||||
RENDERER_LOGD("Effect destruction: %p", this);
|
||||
// RENDERER_LOGD("Effect destruction: %p", this);
|
||||
}
|
||||
|
||||
void Effect::clear()
|
||||
|
||||
@@ -48,6 +48,7 @@ public:
|
||||
void clear();
|
||||
|
||||
Technique* getTechnique(const std::string& stage) const;
|
||||
const Vector<Technique*>& getTechniques() const { return _techniques; }
|
||||
|
||||
Value getDefineValue(const std::string& name) const;
|
||||
void setDefineValue(const std::string& name, const Value& value);
|
||||
|
||||
@@ -43,9 +43,9 @@ ForwardRenderer::ForwardRenderer()
|
||||
{
|
||||
}
|
||||
|
||||
bool ForwardRenderer::init(DeviceGraphics* device, std::vector<ProgramLib::Template>& programTemplates, int width, int height)
|
||||
bool ForwardRenderer::init(DeviceGraphics* device, std::vector<ProgramLib::Template>& programTemplates, Texture2D* defaultTexture, int width, int height)
|
||||
{
|
||||
BaseRenderer::init(device, programTemplates);
|
||||
BaseRenderer::init(device, programTemplates, defaultTexture);
|
||||
_width = width;
|
||||
_height = height;
|
||||
registerStage("transparent", std::bind(&ForwardRenderer::transparentStage, this, std::placeholders::_1, std::placeholders::_2));
|
||||
@@ -78,23 +78,23 @@ void ForwardRenderer::transparentStage(const View* view, const std::vector<Stage
|
||||
for (const auto& item : items)
|
||||
{
|
||||
// Update vertex buffer and index buffer
|
||||
InputAssembler* ia = item.ia;
|
||||
VertexBuffer* vb = ia->getVertexBuffer();
|
||||
size_t vertexDataBytes = 0;
|
||||
uint8_t* vertexData = vb->invokeFetchDataCallback(&vertexDataBytes);
|
||||
assert(vertexData != nullptr);
|
||||
assert(vertexDataBytes > 0);
|
||||
// RENDERER_LOGD("vertexBuffer size: %d", (int)vertexDataBytes);
|
||||
|
||||
IndexBuffer* ib = ia->getIndexBuffer();
|
||||
size_t indexDataBytes = 0;
|
||||
uint8_t* indexData = ib->invokeFetchDataCallback(&indexDataBytes);
|
||||
assert(indexData != nullptr);
|
||||
assert(indexDataBytes > 0);
|
||||
// RENDERER_LOGD("indexBuffer size: %d", (int)indexDataBytes);
|
||||
|
||||
vb->update(0, vertexData, vertexDataBytes);
|
||||
ib->update(0, indexData, indexDataBytes);
|
||||
// InputAssembler* ia = item.ia;
|
||||
// VertexBuffer* vb = ia->getVertexBuffer();
|
||||
// size_t vertexDataBytes = 0;
|
||||
// uint8_t* vertexData = vb->invokeFetchDataCallback(&vertexDataBytes);
|
||||
// assert(vertexData != nullptr);
|
||||
// assert(vertexDataBytes > 0);
|
||||
//// RENDERER_LOGD("vertexBuffer size: %d", (int)vertexDataBytes);
|
||||
//
|
||||
// IndexBuffer* ib = ia->getIndexBuffer();
|
||||
// size_t indexDataBytes = 0;
|
||||
// uint8_t* indexData = ib->invokeFetchDataCallback(&indexDataBytes);
|
||||
// assert(indexData != nullptr);
|
||||
// assert(indexDataBytes > 0);
|
||||
//// RENDERER_LOGD("indexBuffer size: %d", (int)indexDataBytes);
|
||||
//
|
||||
// vb->update(0, vertexData, vertexDataBytes);
|
||||
// ib->update(0, indexData, indexDataBytes);
|
||||
draw(item);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -33,7 +33,7 @@ class ForwardRenderer final : public BaseRenderer
|
||||
public:
|
||||
ForwardRenderer();
|
||||
|
||||
bool init(DeviceGraphics* device, std::vector<ProgramLib::Template>& programTemplates, int width, int height);
|
||||
bool init(DeviceGraphics* device, std::vector<ProgramLib::Template>& programTemplates, Texture2D* defaultTexture, int width, int height);
|
||||
void render(Scene* scene);
|
||||
|
||||
private:
|
||||
|
||||
@@ -30,7 +30,7 @@ RENDERER_BEGIN
|
||||
|
||||
Model::Model()
|
||||
{
|
||||
RENDERER_LOGD("Model construction %p", this);
|
||||
// RENDERER_LOGD("Model construction %p", this);
|
||||
}
|
||||
|
||||
Model::~Model()
|
||||
|
||||
@@ -29,12 +29,12 @@ RENDERER_BEGIN
|
||||
Pass::Pass(const std::string& programName)
|
||||
: _programName(programName)
|
||||
{
|
||||
RENDERER_LOGD("Pass constructor: %p", this);
|
||||
// RENDERER_LOGD("Pass constructor: %p", this);
|
||||
}
|
||||
|
||||
Pass::~Pass()
|
||||
{
|
||||
RENDERER_LOGD("Pass destructor: %p", this);
|
||||
// RENDERER_LOGD("Pass destructor: %p", this);
|
||||
}
|
||||
|
||||
void Pass::setCullMode(CullMode cullMode)
|
||||
|
||||
@@ -62,6 +62,8 @@ public:
|
||||
StencilOp stencilZFailOp = StencilOp::KEEP,
|
||||
StencilOp stencilZPassOp = StencilOp::KEEP,
|
||||
uint8_t stencilWriteMask = 0xff);
|
||||
inline void setStencilTest(bool value) { _stencilTest = value; }
|
||||
inline bool getStencilTest() const { return _stencilTest; }
|
||||
|
||||
private:
|
||||
friend class BaseRenderer;
|
||||
|
||||
@@ -367,12 +367,12 @@ Technique::Technique(const std::vector<std::string>& stages,
|
||||
, _passes(passes)
|
||||
, _layer(layer)
|
||||
{
|
||||
RENDERER_LOGD("Technique construction: %p", this);
|
||||
// RENDERER_LOGD("Technique construction: %p", this);
|
||||
}
|
||||
|
||||
Technique::~Technique()
|
||||
{
|
||||
RENDERER_LOGD("Technique destruction: %p", this);
|
||||
// RENDERER_LOGD("Technique destruction: %p", this);
|
||||
}
|
||||
|
||||
void Technique::setStages(const std::vector<std::string>& stages)
|
||||
@@ -380,4 +380,9 @@ void Technique::setStages(const std::vector<std::string>& stages)
|
||||
_stageIDs = Config::getStageIDs(stages);
|
||||
}
|
||||
|
||||
void Technique::setPass(int index, Pass* pass)
|
||||
{
|
||||
_passes.replace(index, pass);
|
||||
}
|
||||
|
||||
RENDERER_END
|
||||
|
||||
@@ -86,7 +86,7 @@ public:
|
||||
inline uint8_t getCount() const { return _count; }
|
||||
inline void* getValue() const { return _value; }
|
||||
inline uint16_t getBytes() const { return _bytes; };
|
||||
|
||||
|
||||
std::vector<Texture*> getTextureArray() const;
|
||||
void setTexture(Texture* texture);
|
||||
Texture* getTexture() const;
|
||||
@@ -115,14 +115,12 @@ public:
|
||||
virtual ~Technique();
|
||||
|
||||
void setStages(const std::vector<std::string>& stages);
|
||||
|
||||
// Should rename function name in binding codes.
|
||||
void setPass(int index, Pass* pass);
|
||||
|
||||
const std::vector<Parameter>& getParameters() const { return _parameters; }
|
||||
const Vector<Pass*>& getPasses() const { return _passes; }
|
||||
uint32_t getStageIDs() const { return _stageIDs; }
|
||||
|
||||
// TODO: add get functions
|
||||
const std::vector<Parameter>& getParameters() const { return _parameters; }
|
||||
|
||||
private:
|
||||
static uint32_t _genID;
|
||||
|
||||
|
||||
@@ -372,22 +372,24 @@ static bool js_renderer_ForwardRenderer_init(se::State& s)
|
||||
const auto& args = s.args();
|
||||
size_t argc = args.size();
|
||||
CC_UNUSED bool ok = true;
|
||||
if (argc == 4) {
|
||||
if (argc == 5) {
|
||||
cocos2d::renderer::DeviceGraphics* arg0 = nullptr;
|
||||
std::vector<cocos2d::renderer::ProgramLib::Template> arg1;
|
||||
int arg2 = 0;
|
||||
cocos2d::renderer::Texture2D* arg2 = nullptr;
|
||||
int arg3 = 0;
|
||||
int arg4 = 0;
|
||||
ok &= seval_to_native_ptr(args[0], &arg0);
|
||||
ok &= seval_to_std_vector_ProgramLib_Template(args[1], &arg1);
|
||||
do { int32_t tmp = 0; ok &= seval_to_int32(args[2], &tmp); arg2 = (int)tmp; } while(false);
|
||||
ok &= seval_to_native_ptr(args[2], &arg2);
|
||||
do { int32_t tmp = 0; ok &= seval_to_int32(args[3], &tmp); arg3 = (int)tmp; } while(false);
|
||||
do { int32_t tmp = 0; ok &= seval_to_int32(args[4], &tmp); arg4 = (int)tmp; } while(false);
|
||||
SE_PRECONDITION2(ok, false, "js_renderer_ForwardRenderer_init : Error processing arguments");
|
||||
bool result = cobj->init(arg0, arg1, arg2, arg3);
|
||||
bool result = cobj->init(arg0, arg1, arg2, arg3, arg4);
|
||||
ok &= boolean_to_seval(result, &s.rval());
|
||||
SE_PRECONDITION2(ok, false, "js_renderer_ForwardRenderer_init : Error processing arguments");
|
||||
return true;
|
||||
}
|
||||
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4);
|
||||
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 5);
|
||||
return false;
|
||||
}
|
||||
SE_BIND_FUNC(js_renderer_ForwardRenderer_init)
|
||||
@@ -1171,27 +1173,6 @@ static bool js_renderer_Effect_clear(se::State& s)
|
||||
}
|
||||
SE_BIND_FUNC(js_renderer_Effect_clear)
|
||||
|
||||
static bool js_renderer_Effect_setProperty(se::State& s)
|
||||
{
|
||||
cocos2d::renderer::Effect* cobj = (cocos2d::renderer::Effect*)s.nativeThisObject();
|
||||
SE_PRECONDITION2(cobj, false, "js_renderer_Effect_setProperty : Invalid Native Object");
|
||||
const auto& args = s.args();
|
||||
size_t argc = args.size();
|
||||
CC_UNUSED bool ok = true;
|
||||
if (argc == 2) {
|
||||
std::string arg0;
|
||||
cocos2d::renderer::Technique::Parameter arg1;
|
||||
ok &= seval_to_std_string(args[0], &arg0);
|
||||
ok &= seval_to_TechniqueParameter(args[1], &arg1);
|
||||
SE_PRECONDITION2(ok, false, "js_renderer_Effect_setProperty : Error processing arguments");
|
||||
cobj->setProperty(arg0, arg1);
|
||||
return true;
|
||||
}
|
||||
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
|
||||
return false;
|
||||
}
|
||||
SE_BIND_FUNC(js_renderer_Effect_setProperty)
|
||||
|
||||
static bool js_renderer_Effect_getTechnique(se::State& s)
|
||||
{
|
||||
cocos2d::renderer::Effect* cobj = (cocos2d::renderer::Effect*)s.nativeThisObject();
|
||||
@@ -1275,7 +1256,6 @@ bool js_register_renderer_Effect(se::Object* obj)
|
||||
cls->defineFunction("getDefineValue", _SE(js_renderer_Effect_getDefineValue));
|
||||
cls->defineFunction("getProperty", _SE(js_renderer_Effect_getProperty));
|
||||
cls->defineFunction("clear", _SE(js_renderer_Effect_clear));
|
||||
cls->defineFunction("setProperty", _SE(js_renderer_Effect_setProperty));
|
||||
cls->defineFunction("getTechnique", _SE(js_renderer_Effect_getTechnique));
|
||||
cls->defineFunction("define", _SE(js_renderer_Effect_setDefineValue));
|
||||
cls->defineFinalizeFunction(_SE(js_cocos2d_renderer_Effect_finalize));
|
||||
@@ -3131,6 +3111,47 @@ bool js_register_renderer_Scene(se::Object* obj)
|
||||
return true;
|
||||
}
|
||||
|
||||
se::Object* __jsb_cocos2d_renderer_ProgramLib_proto = nullptr;
|
||||
se::Class* __jsb_cocos2d_renderer_ProgramLib_class = nullptr;
|
||||
|
||||
static bool js_renderer_ProgamLib_getProgram(se::State& s)
|
||||
{
|
||||
cocos2d::renderer::ProgramLib* cobj = (cocos2d::renderer::ProgramLib*)s.nativeThisObject();
|
||||
SE_PRECONDITION2(cobj, false, "js_renderer_ProgamLib_getProgam : Invalid Native Object");
|
||||
const auto& args = s.args();
|
||||
size_t argc = args.size();
|
||||
CC_UNUSED bool ok = true;
|
||||
if (argc == 2) {
|
||||
std::string arg0;
|
||||
cocos2d::ValueMap arg1;
|
||||
ok &= seval_to_std_string(args[0], &arg0);
|
||||
SE_PRECONDITION2(ok, false, "js_renderer_ProgamLib_getProgam : Error processing arguments 0");
|
||||
ok &= seval_to_ccvaluemap(args[1], &arg1);
|
||||
SE_PRECONDITION2(ok, false, "js_renderer_ProgamLib_getProgam : Error processing arguments 1");
|
||||
auto result = cobj->getProgram(arg0, arg1);
|
||||
native_ptr_to_seval<cocos2d::renderer::Program>(result, &s.rval());
|
||||
return true;
|
||||
}
|
||||
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1);
|
||||
return false;
|
||||
}
|
||||
SE_BIND_FUNC(js_renderer_ProgamLib_getProgram)
|
||||
|
||||
bool js_register_renderer_ProgramLib(se::Object* obj)
|
||||
{
|
||||
auto cls = se::Class::create("ProgramLib", obj, nullptr, nullptr);
|
||||
|
||||
cls->defineFunction("getProgram", _SE(js_renderer_ProgamLib_getProgram));
|
||||
cls->install();
|
||||
JSBClassType::registerClass<cocos2d::renderer::ProgramLib>(cls);
|
||||
|
||||
__jsb_cocos2d_renderer_ProgramLib_proto = cls->getProto();
|
||||
__jsb_cocos2d_renderer_ProgramLib_class = cls;
|
||||
|
||||
se::ScriptEngine::getInstance()->clearException();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool register_all_renderer(se::Object* obj)
|
||||
{
|
||||
// Get the ns
|
||||
@@ -3154,6 +3175,7 @@ bool register_all_renderer(se::Object* obj)
|
||||
js_register_renderer_Model(ns);
|
||||
js_register_renderer_ForwardRenderer(ns);
|
||||
js_register_renderer_View(ns);
|
||||
js_register_renderer_ProgramLib(ns);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
@@ -94,7 +94,6 @@ bool register_all_renderer(se::Object* obj);
|
||||
SE_DECLARE_FUNC(js_renderer_Effect_getDefineValue);
|
||||
SE_DECLARE_FUNC(js_renderer_Effect_getProperty);
|
||||
SE_DECLARE_FUNC(js_renderer_Effect_clear);
|
||||
SE_DECLARE_FUNC(js_renderer_Effect_setProperty);
|
||||
SE_DECLARE_FUNC(js_renderer_Effect_getTechnique);
|
||||
SE_DECLARE_FUNC(js_renderer_Effect_setDefineValue);
|
||||
SE_DECLARE_FUNC(js_renderer_Effect_Effect);
|
||||
@@ -196,3 +195,8 @@ SE_DECLARE_FUNC(js_renderer_Scene_addLight);
|
||||
SE_DECLARE_FUNC(js_renderer_Scene_removeLight);
|
||||
SE_DECLARE_FUNC(js_renderer_Scene_Scene);
|
||||
|
||||
extern se::Object* __jsb_cocos2d_renderer_ProgramLib_proto;
|
||||
extern se::Class* __jsb_cocos2d_renderer_ProgramLib_class;
|
||||
bool js_register_renderer_ProgramLib(se::Object* obj);
|
||||
SE_DECLARE_FUNC(js_renderer_ProgramLib_getProgram);
|
||||
|
||||
|
||||
@@ -156,7 +156,11 @@ namespace se {
|
||||
if (isSupportTypedArrayAPI())
|
||||
{
|
||||
void* copiedData = malloc(byteLength);
|
||||
memcpy(copiedData, data, byteLength);
|
||||
if (data)
|
||||
memcpy(copiedData, data, byteLength);
|
||||
else
|
||||
memset(copiedData, 0, byteLength);
|
||||
|
||||
JSValueRef exception = nullptr;
|
||||
JSTypedArrayType jscTypedArrayType = kJSTypedArrayTypeNone;
|
||||
Type objectType = Type::UNKNOWN;
|
||||
|
||||
@@ -320,7 +320,7 @@ static bool js_cocos2dx_##cls_set_##property(se::State& s) \
|
||||
SE_PRECONDITION2(cobj, false, "js_cocos2dx_#cls_set_#property : Invalid Native Object"); \
|
||||
const auto& args = s.args(); \
|
||||
size_t argc = args.size(); \
|
||||
CC_UNUSED bool ok = true; \
|
||||
bool ok = true; \
|
||||
if (argc == 1) { \
|
||||
type arg0; \
|
||||
ok &= convertFunc(args[0], &arg0); \
|
||||
|
||||
@@ -293,6 +293,23 @@ bool seval_to_Vec4(const se::Value& v, cocos2d::Vec4* pt)
|
||||
return true;
|
||||
}
|
||||
|
||||
bool seval_to_mat(const se::Value& v, int length, float* out)
|
||||
{
|
||||
assert(v.isObject() && out != nullptr);
|
||||
se::Object* obj = v.toObject();
|
||||
|
||||
se::Value tmp;
|
||||
char propName[3] = {0};
|
||||
for (int i = 0; i < length; ++i)
|
||||
{
|
||||
snprintf(propName, 3, "m%2d", i);
|
||||
obj->getProperty(propName, &tmp);
|
||||
*(out + i) = tmp.toFloat();
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool seval_to_Mat4(const se::Value& v, cocos2d::Mat4* mat)
|
||||
{
|
||||
assert(v.isObject() && mat != nullptr);
|
||||
@@ -1391,9 +1408,13 @@ bool seval_to_TextureOptions(const se::Value& v, cocos2d::renderer::Texture::Opt
|
||||
imgData.copy((unsigned char*)data, bytes);
|
||||
ret->images.push_back(std::move(imgData));
|
||||
}
|
||||
else if (imageVal.isNull())
|
||||
{
|
||||
// ret->images.push_back(cocos2d::Data());
|
||||
}
|
||||
else
|
||||
{
|
||||
SE_LOGE("Texture image isn't a typed array object!");
|
||||
SE_LOGE("Texture image isn't a typed array object or null!");
|
||||
assert(false);
|
||||
}
|
||||
}
|
||||
@@ -1696,6 +1717,123 @@ bool seval_to_EffectDefineTemplate(const se::Value& v, std::vector<cocos2d::Valu
|
||||
return true;
|
||||
}
|
||||
|
||||
bool seval_to_TechniqueParameter_not_constructor(const se::Value& v, cocos2d::renderer::Technique::Parameter* ret)
|
||||
{
|
||||
assert(ret != nullptr);
|
||||
|
||||
auto paramType = ret->getType();
|
||||
switch (paramType)
|
||||
{
|
||||
case cocos2d::renderer::Technique::Parameter::Type::INT:
|
||||
{
|
||||
int32_t value;
|
||||
seval_to_int32(v, &value);
|
||||
cocos2d::renderer::Technique::Parameter param(ret->getName(), paramType, &value);
|
||||
*ret = std::move(param);
|
||||
break;
|
||||
}
|
||||
case cocos2d::renderer::Technique::Parameter::Type::INT2:
|
||||
{
|
||||
cocos2d::Vec2 vec2;
|
||||
seval_to_Vec2(v, &vec2);
|
||||
int data[2] = {(int)vec2.x, (int)vec2.y};
|
||||
cocos2d::renderer::Technique::Parameter param(ret->getName(), paramType, data, 2);
|
||||
*ret = std::move(param);
|
||||
break;
|
||||
}
|
||||
case cocos2d::renderer::Technique::Parameter::Type::INT3:
|
||||
{
|
||||
cocos2d::Vec3 vec3;
|
||||
seval_to_Vec3(v, &vec3);
|
||||
int data[3] = {(int)vec3.x, (int)vec3.y, (int)vec3.z};
|
||||
cocos2d::renderer::Technique::Parameter param(ret->getName(), paramType, data, 3);
|
||||
*ret = std::move(param);
|
||||
break;
|
||||
}
|
||||
case cocos2d::renderer::Technique::Parameter::Type::INT4:
|
||||
{
|
||||
cocos2d::Vec4 vec4;
|
||||
seval_to_Vec4(v, &vec4);
|
||||
int data[4] = {(int)vec4.x, (int)vec4.y, (int)vec4.z, (int)vec4.w};
|
||||
cocos2d::renderer::Technique::Parameter param(ret->getName(), paramType, data, 4);
|
||||
*ret = std::move(param);
|
||||
break;
|
||||
}
|
||||
case cocos2d::renderer::Technique::Parameter::Type::FLOAT:
|
||||
{
|
||||
float value;
|
||||
seval_to_float(v, &value);
|
||||
cocos2d::renderer::Technique::Parameter param(ret->getName(), paramType, &value);
|
||||
*ret = std::move(param);
|
||||
break;
|
||||
}
|
||||
case cocos2d::renderer::Technique::Parameter::Type::FLOAT2:
|
||||
{
|
||||
cocos2d::Vec2 vec2;
|
||||
seval_to_Vec2(v, &vec2);
|
||||
float data[2] = {vec2.x, vec2.y};
|
||||
cocos2d::renderer::Technique::Parameter param(ret->getName(), paramType, data, 2);
|
||||
*ret = std::move(param);
|
||||
break;
|
||||
}
|
||||
case cocos2d::renderer::Technique::Parameter::Type::FLOAT3:
|
||||
{
|
||||
cocos2d::Vec3 vec3;
|
||||
seval_to_Vec3(v, &vec3);
|
||||
float data[3] = {vec3.x, vec3.y, vec3.z};
|
||||
cocos2d::renderer::Technique::Parameter param(ret->getName(), paramType, data, 3);
|
||||
*ret = std::move(param);
|
||||
break;
|
||||
}
|
||||
case cocos2d::renderer::Technique::Parameter::Type::FLOAT4:
|
||||
{
|
||||
cocos2d::Vec4 vec4;
|
||||
seval_to_Vec4(v, &vec4);
|
||||
float data[4] = {vec4.x, vec4.y, vec4.z, vec4.w};
|
||||
cocos2d::renderer::Technique::Parameter param(ret->getName(), paramType, data, 4);
|
||||
*ret = std::move(param);
|
||||
break;
|
||||
}
|
||||
case cocos2d::renderer::Technique::Parameter::Type::MAT4:
|
||||
{
|
||||
cocos2d::Mat4 mat4;
|
||||
seval_to_Mat4(v, &mat4);
|
||||
cocos2d::renderer::Technique::Parameter param(ret->getName(), paramType, mat4.m, 16);
|
||||
*ret = std::move(param);
|
||||
break;
|
||||
}
|
||||
case cocos2d::renderer::Technique::Parameter::Type::MAT3:
|
||||
{
|
||||
float* data = nullptr;
|
||||
seval_to_mat(v, 9, data);
|
||||
cocos2d::renderer::Technique::Parameter param(ret->getName(), paramType, data, 9);
|
||||
*ret = std::move(param);
|
||||
break;
|
||||
}
|
||||
case cocos2d::renderer::Technique::Parameter::Type::MAT2:
|
||||
{
|
||||
float* data = nullptr;
|
||||
seval_to_mat(v, 4, data);
|
||||
cocos2d::renderer::Technique::Parameter param(ret->getName(), paramType, data, 4);
|
||||
*ret = std::move(param);
|
||||
break;
|
||||
}
|
||||
case cocos2d::renderer::Technique::Parameter::Type::TEXTURE_2D:
|
||||
{
|
||||
cocos2d::renderer::Texture* texture = nullptr;
|
||||
seval_to_native_ptr(v, &texture);
|
||||
cocos2d::renderer::Technique::Parameter param(ret->getName(), paramType, texture);
|
||||
*ret = std::move(param);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
assert(false);
|
||||
break;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
bool seval_to_TechniqueParameter(const se::Value& v, cocos2d::renderer::Technique::Parameter* ret)
|
||||
{
|
||||
assert(ret != nullptr);
|
||||
@@ -1710,12 +1848,12 @@ bool seval_to_TechniqueParameter(const se::Value& v, cocos2d::renderer::Techniqu
|
||||
std::vector<cocos2d::renderer::Texture*> textures;
|
||||
cocos2d::renderer::Texture* texture = nullptr;
|
||||
|
||||
std::vector<std::string> keys;
|
||||
obj->getAllKeys(&keys);
|
||||
for (auto& key: keys)
|
||||
{
|
||||
SE_LOGD("key: %s\n", key.c_str());
|
||||
}
|
||||
// std::vector<std::string> keys;
|
||||
// obj->getAllKeys(&keys);
|
||||
// for (auto& key: keys)
|
||||
// {
|
||||
//// SE_LOGD("key: %s\n", key.c_str());
|
||||
// }
|
||||
|
||||
bool ok = false;
|
||||
|
||||
@@ -2961,13 +3099,98 @@ bool VertexFormat_to_seval(const cocos2d::renderer::VertexFormat& v, se::Value*
|
||||
return true;
|
||||
}
|
||||
|
||||
namespace
|
||||
{
|
||||
enum class DataType
|
||||
{
|
||||
INT,
|
||||
FLOAT
|
||||
};
|
||||
|
||||
void toVec2(void* data, DataType type, se::Value* ret)
|
||||
{
|
||||
int32_t* intptr = (int32_t*)data;
|
||||
float* floatptr = (float*)data;
|
||||
cocos2d::Vec2 vec2;
|
||||
if (DataType::INT == type)
|
||||
{
|
||||
vec2.x = *intptr;
|
||||
vec2.y = *(intptr + 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
vec2.x = *floatptr;
|
||||
vec2.y = *(floatptr + 1);
|
||||
}
|
||||
|
||||
Vec2_to_seval(vec2, ret);
|
||||
}
|
||||
|
||||
void toVec3(void* data, DataType type, se::Value* ret)
|
||||
{
|
||||
int32_t* intptr = (int32_t*)data;
|
||||
float* floatptr = (float*)data;
|
||||
cocos2d::Vec3 vec3;
|
||||
if (DataType::INT == type)
|
||||
{
|
||||
vec3.x = *intptr;
|
||||
vec3.y = *(intptr + 1);
|
||||
vec3.z = *(intptr + 2);
|
||||
}
|
||||
else
|
||||
{
|
||||
vec3.x = *floatptr;
|
||||
vec3.y = *(floatptr + 1);
|
||||
vec3.z = *(floatptr + 2);
|
||||
}
|
||||
|
||||
Vec3_to_seval(vec3, ret);
|
||||
}
|
||||
|
||||
void toVec4(void* data, DataType type, se::Value* ret)
|
||||
{
|
||||
int32_t* intptr = (int32_t*)data;
|
||||
float* floatptr = (float*)data;
|
||||
cocos2d::Vec4 vec4;
|
||||
if (DataType::INT == type)
|
||||
{
|
||||
vec4.x = *intptr;
|
||||
vec4.y = *(intptr + 1);
|
||||
vec4.z = *(intptr + 2);
|
||||
vec4.w = *(intptr + 3);
|
||||
}
|
||||
else
|
||||
{
|
||||
vec4.x = *floatptr;
|
||||
vec4.y = *(floatptr + 1);
|
||||
vec4.z = *(floatptr + 2);
|
||||
vec4.w = *(floatptr + 3);
|
||||
}
|
||||
|
||||
Vec4_to_seval(vec4, ret);
|
||||
}
|
||||
|
||||
void toMat(float* data, int num, se::Value* ret)
|
||||
{
|
||||
se::HandleObject obj(se::Object::createPlainObject());
|
||||
|
||||
char propName[4] = {0};
|
||||
for (int i = 0; i < num; ++i)
|
||||
{
|
||||
if (i < 10)
|
||||
snprintf(propName, 3, "m0%d", i);
|
||||
else
|
||||
snprintf(propName, 3, "m%d", i);
|
||||
|
||||
obj->setProperty(propName, se::Value(*(data + i)));
|
||||
}
|
||||
ret->setObject(obj);
|
||||
}
|
||||
}
|
||||
|
||||
bool TechniqueParameter_to_seval(const cocos2d::renderer::Technique::Parameter& v, se::Value* ret)
|
||||
{
|
||||
assert(ret != nullptr);
|
||||
// se::HandleObject obj(se::Object::createPlainObject());
|
||||
// obj->setProperty("name", se::Value(v.getName()));
|
||||
// obj->setProperty("type", se::Value((uint8_t)v.getType()));
|
||||
// obj->setProperty("size", se::Value(v.getCount()));
|
||||
|
||||
auto type = v.getType();
|
||||
if (type == cocos2d::renderer::Technique::Parameter::Type::TEXTURE_2D || type == cocos2d::renderer::Technique::Parameter::Type::TEXTURE_CUBE)
|
||||
@@ -2983,34 +3206,58 @@ bool TechniqueParameter_to_seval(const cocos2d::renderer::Technique::Parameter&
|
||||
native_ptr_to_seval<cocos2d::renderer::Texture>(texArray[0], &val);
|
||||
arr->setArrayElement(i, val);
|
||||
}
|
||||
// obj->setProperty("val", se::Value(arr));
|
||||
ret->setObject(arr);
|
||||
}
|
||||
else
|
||||
{
|
||||
se::Value val;
|
||||
native_ptr_to_seval<cocos2d::renderer::Texture>(v.getTexture(), &val);
|
||||
// obj->setProperty("val", val);
|
||||
*ret = val;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
void* data = v.getValue();
|
||||
auto bytes = v.getBytes();
|
||||
|
||||
if (type == cocos2d::renderer::Technique::Parameter::Type::INT
|
||||
|| type == cocos2d::renderer::Technique::Parameter::Type::INT2
|
||||
|| type == cocos2d::renderer::Technique::Parameter::Type::INT3
|
||||
|| type == cocos2d::renderer::Technique::Parameter::Type::INT4)
|
||||
{
|
||||
se::HandleObject typedArr(se::Object::createTypedArray(se::Object::TypedArrayType::INT32, data, bytes));
|
||||
// obj->setProperty("val", se::Value(typedArr));
|
||||
ret->setObject(typedArr);
|
||||
|
||||
switch (type) {
|
||||
case cocos2d::renderer::Technique::Parameter::Type::INT:
|
||||
ret->setInt32(*((int32_t*)data));
|
||||
break;
|
||||
case cocos2d::renderer::Technique::Parameter::Type::INT2:
|
||||
toVec2(data, DataType::INT, ret);
|
||||
break;
|
||||
case cocos2d::renderer::Technique::Parameter::Type::INT3:
|
||||
toVec3(data, DataType::INT, ret);
|
||||
break;
|
||||
case cocos2d::renderer::Technique::Parameter::Type::INT4:
|
||||
toVec4(data, DataType::INT, ret);
|
||||
break;
|
||||
case cocos2d::renderer::Technique::Parameter::Type::FLOAT:
|
||||
ret->setFloat(*((float*)data));
|
||||
break;
|
||||
case cocos2d::renderer::Technique::Parameter::Type::FLOAT2:
|
||||
toVec2(data, DataType::FLOAT, ret);
|
||||
break;
|
||||
case cocos2d::renderer::Technique::Parameter::Type::FLOAT3:
|
||||
toVec3(data, DataType::FLOAT, ret);
|
||||
case cocos2d::renderer::Technique::Parameter::Type::FLOAT4:
|
||||
toVec4(data, DataType::FLOAT, ret);
|
||||
break;
|
||||
case cocos2d::renderer::Technique::Parameter::Type::MAT2:
|
||||
toMat((float*)data, 4, ret);
|
||||
break;
|
||||
case cocos2d::renderer::Technique::Parameter::Type::MAT3:
|
||||
toMat((float*)data, 9, ret);
|
||||
break;
|
||||
case cocos2d::renderer::Technique::Parameter::Type::MAT4:
|
||||
toMat((float*)data, 16, ret);
|
||||
break;
|
||||
default:
|
||||
assert(false);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// ret->setObject(obj);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
@@ -105,6 +105,7 @@ bool seval_to_TextureSubImageOption(const se::Value& v, cocos2d::renderer::Textu
|
||||
bool seval_to_TextureImageOption(const se::Value& v, cocos2d::renderer::Texture::ImageOption* ret);
|
||||
bool seval_to_EffectProperty(const se::Value& v, std::unordered_map<std::string, cocos2d::renderer::Effect::Property>* ret);
|
||||
bool seval_to_EffectDefineTemplate(const se::Value& v, std::vector<cocos2d::ValueMap>* ret);
|
||||
bool seval_to_TechniqueParameter_not_constructor(const se::Value& v, cocos2d::renderer::Technique::Parameter* ret);
|
||||
bool seval_to_TechniqueParameter(const se::Value& v, cocos2d::renderer::Technique::Parameter* ret);
|
||||
bool seval_to_std_vector_TechniqueParameter(const se::Value& v, std::vector<cocos2d::renderer::Technique::Parameter>* ret);
|
||||
bool seval_to_std_vector_ProgramLib_Template(const se::Value& v, std::vector<cocos2d::renderer::ProgramLib::Template>* ret);
|
||||
|
||||
@@ -298,7 +298,7 @@ namespace {
|
||||
#endif
|
||||
|
||||
|
||||
RENDERER_LOGD("Evaluate: %s", reletivePath.c_str());
|
||||
// RENDERER_LOGD("Evaluate: %s", fullPath.c_str());
|
||||
|
||||
auto se = se::ScriptEngine::getInstance();
|
||||
bool succeed = se->evalString(scriptBuffer.c_str(), scriptBuffer.length(), nullptr, reletivePath.c_str());
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
#include "cocos/scripting/js-bindings/manual/jsb_conversions.hpp"
|
||||
// #include "Renderer.h"
|
||||
#include "renderer/INode.h"
|
||||
#include "jsb_conversions.hpp"
|
||||
|
||||
using namespace cocos2d;
|
||||
using namespace cocos2d::renderer;
|
||||
@@ -181,6 +182,45 @@ static bool js_renderer_Effect_extractDefines(se::State& s)
|
||||
}
|
||||
SE_BIND_FUNC(js_renderer_Effect_extractDefines)
|
||||
|
||||
static bool js_renderer_Effect_setProperty(se::State& s)
|
||||
{
|
||||
cocos2d::renderer::Effect* cobj = (cocos2d::renderer::Effect*)s.nativeThisObject();
|
||||
SE_PRECONDITION2(cobj, false, "js_renderer_Effect_setProperty : Invalid Native Object");
|
||||
const auto& args = s.args();
|
||||
size_t argc = args.size();
|
||||
CC_UNUSED bool ok = true;
|
||||
if (argc == 2) {
|
||||
std::string arg0;
|
||||
|
||||
ok &= seval_to_std_string(args[0], &arg0);
|
||||
|
||||
// get property type by arg0
|
||||
cocos2d::renderer::Technique::Parameter::Type propType = cocos2d::renderer::Technique::Parameter::Type::UNKNOWN;
|
||||
const auto& techinques = cobj->getTechniques();
|
||||
for (const auto& techinque : techinques)
|
||||
{
|
||||
const auto& parameters = techinque->getParameters();
|
||||
for (const auto& param : parameters)
|
||||
{
|
||||
if (arg0 == param.getName())
|
||||
{
|
||||
propType = param.getType();
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
assert(propType != cocos2d::renderer::Technique::Parameter::Type::UNKNOWN);
|
||||
cocos2d::renderer::Technique::Parameter arg1(arg0, propType);
|
||||
ok &= seval_to_TechniqueParameter_not_constructor(args[1], &arg1);
|
||||
SE_PRECONDITION2(ok, false, "js_renderer_Effect_setProperty : Error processing arguments");
|
||||
cobj->setProperty(arg0, arg1);
|
||||
return true;
|
||||
}
|
||||
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 2);
|
||||
return false;
|
||||
}
|
||||
SE_BIND_FUNC(js_renderer_Effect_setProperty)
|
||||
|
||||
static bool js_renderer_Light_extractView(se::State& s)
|
||||
{
|
||||
cocos2d::renderer::Light* cobj = (cocos2d::renderer::Light*)s.nativeThisObject();
|
||||
@@ -285,7 +325,7 @@ public:
|
||||
se::HandleObject obj(se::Object::createPlainObject());
|
||||
args.push_back(se::Value(obj));
|
||||
func.toObject()->call(args, _jsNode.toObject(), &ret);
|
||||
seval_to_Mat4(ret, &worldMatrix);
|
||||
seval_to_Mat4(se::Value(obj), &worldMatrix);
|
||||
}
|
||||
return worldMatrix;
|
||||
}
|
||||
@@ -364,6 +404,135 @@ static bool js_renderer_Model_setNode(se::State& s)
|
||||
}
|
||||
SE_BIND_FUNC(js_renderer_Model_setNode)
|
||||
|
||||
static bool js_renderer_Technique_prop_getPasses(se::State& s)
|
||||
{
|
||||
cocos2d::renderer::Technique* cobj = (cocos2d::renderer::Technique*)s.nativeThisObject();
|
||||
SE_PRECONDITION2(cobj, false, "js_renderer_Technique_getPasses: Invalid Native Object.");
|
||||
const auto& args = s.args();
|
||||
size_t argc = args.size();
|
||||
if (argc == 0)
|
||||
{
|
||||
const auto& passes = cobj->getPasses();
|
||||
Vector_to_seval<cocos2d::renderer::Pass>(passes, &s.rval());
|
||||
return true;
|
||||
}
|
||||
|
||||
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
|
||||
return false;
|
||||
}
|
||||
SE_BIND_PROP_GET(js_renderer_Technique_prop_getPasses);
|
||||
|
||||
static bool js_renderer_Tehchnique_setPass(se::State& s)
|
||||
{
|
||||
cocos2d::renderer::Technique* cobj = (cocos2d::renderer::Technique*)s.nativeThisObject();
|
||||
SE_PRECONDITION2(cobj, false, "js_renderer_Technique_getPasses: Invalid Native Object.");
|
||||
const auto& args = s.args();
|
||||
size_t argc = args.size();
|
||||
if (argc == 2)
|
||||
{
|
||||
int arg0 = 0;
|
||||
cocos2d::renderer::Pass* arg1 = nullptr;
|
||||
|
||||
bool ok = seval_to_int32(args[0], &arg0);
|
||||
SE_PRECONDITION2(ok, false, "js_renderer_Tehchnique_setPass: Can not convert arg1 to int.");
|
||||
|
||||
ok |= seval_to_native_ptr(args[1], &arg1);
|
||||
SE_PRECONDITION2(ok, false, "js_renderer_Tehchnique_setPass: Can not convert arg0 to Pass*.");
|
||||
|
||||
cobj->setPass(arg0, arg1);
|
||||
return true;
|
||||
}
|
||||
|
||||
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
|
||||
return false;
|
||||
}
|
||||
SE_BIND_FUNC(js_renderer_Tehchnique_setPass);
|
||||
|
||||
static bool js_renderer_Pass_prop_getStencilTest(se::State& s)
|
||||
{
|
||||
cocos2d::renderer::Pass* cobj = (cocos2d::renderer::Pass*)s.nativeThisObject();
|
||||
SE_PRECONDITION2(cobj, false, "js_renderer_Pass_getStencilTest: Invalid Native Object.");
|
||||
const auto& args = s.args();
|
||||
size_t argc = args.size();
|
||||
if (argc == 0)
|
||||
{
|
||||
bool stencilTest = cobj->getStencilTest();
|
||||
boolean_to_seval(stencilTest, &s.rval());
|
||||
return true;
|
||||
}
|
||||
|
||||
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
|
||||
return false;
|
||||
}
|
||||
SE_BIND_PROP_GET(js_renderer_Pass_prop_getStencilTest);
|
||||
|
||||
static bool js_renderer_Pass_prop_setStencilTest(se::State& s)
|
||||
{
|
||||
cocos2d::renderer::Pass* cobj = (cocos2d::renderer::Pass*)s.nativeThisObject();
|
||||
SE_PRECONDITION2(cobj, false, "js_renderer_Pass_sStencilTest: Invalid Native Object.");
|
||||
const auto& args = s.args();
|
||||
size_t argc = args.size();
|
||||
if (argc == 1)
|
||||
{
|
||||
bool arg0 = false;
|
||||
bool ok = seval_to_boolean(args[0], &arg0);
|
||||
SE_PRECONDITION2(ok, false, "js_renderer_Pass_prop_setStencilTest : can not convert arg0 to bool");
|
||||
cobj->setStencilTest(arg0);
|
||||
return true;
|
||||
}
|
||||
|
||||
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
|
||||
return false;
|
||||
}
|
||||
SE_BIND_PROP_SET(js_renderer_Pass_prop_setStencilTest);
|
||||
|
||||
static bool js_renderer_Config_addStage(se::State& s)
|
||||
{
|
||||
const auto& args = s.args();
|
||||
size_t argc = args.size();
|
||||
if (argc == 1)
|
||||
{
|
||||
std::string arg0;
|
||||
bool ok = seval_to_std_string(args[0], &arg0);
|
||||
SE_PRECONDITION2(ok, false, "js_renderer_Scene_addCamera : Error processing arguments");
|
||||
cocos2d::renderer::Config::addStage(arg0);
|
||||
return true;
|
||||
}
|
||||
|
||||
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
|
||||
return false;
|
||||
}
|
||||
SE_BIND_FUNC(js_renderer_Config_addStage);
|
||||
|
||||
static bool js_renderer_BaseRenderer_prop_getProgramLib(se::State& s)
|
||||
{
|
||||
cocos2d::renderer::BaseRenderer* cobj = (cocos2d::renderer::BaseRenderer*)s.nativeThisObject();
|
||||
SE_PRECONDITION2(cobj, false, "js_renderer_BaseRenderer_prop_getProgramLib: Invalid Native Object.");
|
||||
const auto& args = s.args();
|
||||
size_t argc = args.size();
|
||||
if (argc == 0)
|
||||
{
|
||||
auto programLib = cobj->getProgramLib();
|
||||
native_ptr_to_seval<cocos2d::renderer::ProgramLib>(programLib, &s.rval());
|
||||
return true;
|
||||
}
|
||||
|
||||
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
|
||||
return false;
|
||||
}
|
||||
SE_BIND_PROP_GET(js_renderer_BaseRenderer_prop_getProgramLib);
|
||||
|
||||
static bool js_register_renderer_Config(se::Object* obj)
|
||||
{
|
||||
auto cls = se::Class::create("Config", obj, nullptr, nullptr);
|
||||
cls->defineStaticFunction("addStage", _SE(js_renderer_Config_addStage));
|
||||
cls->install();
|
||||
JSBClassType::registerClass<cocos2d::renderer::Config>(cls);
|
||||
|
||||
se::ScriptEngine::getInstance()->clearException();
|
||||
return true;
|
||||
}
|
||||
|
||||
bool jsb_register_renderer_manual(se::Object* global)
|
||||
{
|
||||
// Camera
|
||||
@@ -375,6 +544,7 @@ bool jsb_register_renderer_manual(se::Object* global)
|
||||
|
||||
// Effect
|
||||
__jsb_cocos2d_renderer_Effect_proto->defineFunction("extractDefines", _SE(js_renderer_Effect_extractDefines));
|
||||
__jsb_cocos2d_renderer_Effect_proto->defineFunction("setProperty", _SE(js_renderer_Effect_setProperty));
|
||||
|
||||
// Light
|
||||
__jsb_cocos2d_renderer_Light_proto->defineFunction("extractView", _SE(js_renderer_Light_extractView));
|
||||
@@ -393,6 +563,26 @@ bool jsb_register_renderer_manual(se::Object* global)
|
||||
|
||||
// Model
|
||||
__jsb_cocos2d_renderer_Model_proto->defineFunction("setNode", _SE(js_renderer_Model_setNode));
|
||||
|
||||
// Technique
|
||||
__jsb_cocos2d_renderer_Technique_proto->defineProperty("_passes", _SE(js_renderer_Technique_prop_getPasses), nullptr);
|
||||
|
||||
// BaseRenderer
|
||||
__jsb_cocos2d_renderer_BaseRenderer_proto->defineProperty("_programLib", _SE(js_renderer_BaseRenderer_prop_getProgramLib), nullptr);
|
||||
|
||||
// Config
|
||||
|
||||
// Get the ns
|
||||
se::Value nsVal;
|
||||
if (!global->getProperty("renderer", &nsVal))
|
||||
{
|
||||
se::HandleObject jsobj(se::Object::createPlainObject());
|
||||
nsVal.setObject(jsobj);
|
||||
global->setProperty("renderer", nsVal);
|
||||
}
|
||||
se::Object* ns = nsVal.toObject();
|
||||
|
||||
js_register_renderer_Config(ns);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@@ -30,7 +30,7 @@ replace_headers =
|
||||
# what classes to produce code for. You can use regular expressions here. When testing the regular
|
||||
# expression, it will be enclosed in "^$", like this: "^Menu*$".
|
||||
|
||||
classes = ForwardRenderer BaseRenderer Camera Effect InputAssembler Light Model Pass Scene Technique View
|
||||
classes = ForwardRenderer BaseRenderer Camera Effect InputAssembler Light Model Pass Scene Technique View ProgramLib
|
||||
|
||||
classes_need_extend =
|
||||
|
||||
@@ -43,7 +43,7 @@ classes_need_extend =
|
||||
|
||||
skip = BaseRenderer::[registerStage],
|
||||
Camera::[getColor getRect extractView screenToWorld worldToScreen setNode getNode],
|
||||
Effect::[extractDefines],
|
||||
Effect::[extractDefines setProperty getTechniques],
|
||||
Light::[extractView],
|
||||
Model::[extractDrawItem setNode getNode],
|
||||
View::[getForward getPosition]
|
||||
|
||||
Reference in New Issue
Block a user