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:
James Chen
2018-03-23 15:42:12 +08:00
21 changed files with 589 additions and 107 deletions
@@ -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)
+11 -4
View File
@@ -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);
+2 -2
View File
@@ -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()
+1
View File
@@ -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:
+1 -1
View File
@@ -30,7 +30,7 @@ RENDERER_BEGIN
Model::Model()
{
RENDERER_LOGD("Model construction %p", this);
// RENDERER_LOGD("Model construction %p", this);
}
Model::~Model()
+2 -2
View File
@@ -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)
+2
View File
@@ -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;
+7 -2
View File
@@ -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
+4 -6
View File
@@ -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;
}
+2 -2
View File
@@ -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]