diff --git a/native/cocos/platform/mac/CCCanvasRenderingContext2D-mac.mm b/native/cocos/platform/mac/CCCanvasRenderingContext2D-mac.mm index 81cc197581..6eb6359a05 100644 --- a/native/cocos/platform/mac/CCCanvasRenderingContext2D-mac.mm +++ b/native/cocos/platform/mac/CCCanvasRenderingContext2D-mac.mm @@ -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) diff --git a/native/cocos/renderer/gfx/Texture2D.cpp b/native/cocos/renderer/gfx/Texture2D.cpp index e0745d5e4d..81a51ca35d 100644 --- a/native/cocos/renderer/gfx/Texture2D.cpp +++ b/native/cocos/renderer/gfx/Texture2D.cpp @@ -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).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).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; diff --git a/native/cocos/renderer/renderer/BaseRenderer.h b/native/cocos/renderer/renderer/BaseRenderer.h index 08b872c942..8ab023cda5 100644 --- a/native/cocos/renderer/renderer/BaseRenderer.h +++ b/native/cocos/renderer/renderer/BaseRenderer.h @@ -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); diff --git a/native/cocos/renderer/renderer/Effect.cpp b/native/cocos/renderer/renderer/Effect.cpp index eea1ff081f..fc295e23cb 100644 --- a/native/cocos/renderer/renderer/Effect.cpp +++ b/native/cocos/renderer/renderer/Effect.cpp @@ -34,12 +34,12 @@ Effect::Effect(const Vector& 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() diff --git a/native/cocos/renderer/renderer/Effect.h b/native/cocos/renderer/renderer/Effect.h index 1a675b8dee..91b52108fb 100644 --- a/native/cocos/renderer/renderer/Effect.h +++ b/native/cocos/renderer/renderer/Effect.h @@ -48,6 +48,7 @@ public: void clear(); Technique* getTechnique(const std::string& stage) const; + const Vector& getTechniques() const { return _techniques; } Value getDefineValue(const std::string& name) const; void setDefineValue(const std::string& name, const Value& value); diff --git a/native/cocos/renderer/renderer/ForwardRenderer.cpp b/native/cocos/renderer/renderer/ForwardRenderer.cpp index 1fe7c15f77..ecffdda2db 100644 --- a/native/cocos/renderer/renderer/ForwardRenderer.cpp +++ b/native/cocos/renderer/renderer/ForwardRenderer.cpp @@ -43,9 +43,9 @@ ForwardRenderer::ForwardRenderer() { } -bool ForwardRenderer::init(DeviceGraphics* device, std::vector& programTemplates, int width, int height) +bool ForwardRenderer::init(DeviceGraphics* device, std::vector& 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::vectorgetVertexBuffer(); - 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); } } diff --git a/native/cocos/renderer/renderer/ForwardRenderer.h b/native/cocos/renderer/renderer/ForwardRenderer.h index 6399ca689d..fdc0e2d9bf 100644 --- a/native/cocos/renderer/renderer/ForwardRenderer.h +++ b/native/cocos/renderer/renderer/ForwardRenderer.h @@ -33,7 +33,7 @@ class ForwardRenderer final : public BaseRenderer public: ForwardRenderer(); - bool init(DeviceGraphics* device, std::vector& programTemplates, int width, int height); + bool init(DeviceGraphics* device, std::vector& programTemplates, Texture2D* defaultTexture, int width, int height); void render(Scene* scene); private: diff --git a/native/cocos/renderer/renderer/Model.cpp b/native/cocos/renderer/renderer/Model.cpp index 3d598dba5a..b976646c1e 100644 --- a/native/cocos/renderer/renderer/Model.cpp +++ b/native/cocos/renderer/renderer/Model.cpp @@ -30,7 +30,7 @@ RENDERER_BEGIN Model::Model() { - RENDERER_LOGD("Model construction %p", this); +// RENDERER_LOGD("Model construction %p", this); } Model::~Model() diff --git a/native/cocos/renderer/renderer/Pass.cpp b/native/cocos/renderer/renderer/Pass.cpp index b36a695118..5cc3a2e731 100644 --- a/native/cocos/renderer/renderer/Pass.cpp +++ b/native/cocos/renderer/renderer/Pass.cpp @@ -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) diff --git a/native/cocos/renderer/renderer/Pass.h b/native/cocos/renderer/renderer/Pass.h index cb87b96057..b19c88a4fb 100644 --- a/native/cocos/renderer/renderer/Pass.h +++ b/native/cocos/renderer/renderer/Pass.h @@ -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; diff --git a/native/cocos/renderer/renderer/Technique.cpp b/native/cocos/renderer/renderer/Technique.cpp index 330f2a8c41..22558116a9 100644 --- a/native/cocos/renderer/renderer/Technique.cpp +++ b/native/cocos/renderer/renderer/Technique.cpp @@ -367,12 +367,12 @@ Technique::Technique(const std::vector& 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& stages) @@ -380,4 +380,9 @@ void Technique::setStages(const std::vector& stages) _stageIDs = Config::getStageIDs(stages); } +void Technique::setPass(int index, Pass* pass) +{ + _passes.replace(index, pass); +} + RENDERER_END diff --git a/native/cocos/renderer/renderer/Technique.h b/native/cocos/renderer/renderer/Technique.h index ca5b334df9..5723ff215e 100644 --- a/native/cocos/renderer/renderer/Technique.h +++ b/native/cocos/renderer/renderer/Technique.h @@ -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 getTextureArray() const; void setTexture(Texture* texture); Texture* getTexture() const; @@ -115,14 +115,12 @@ public: virtual ~Technique(); void setStages(const std::vector& stages); - - // Should rename function name in binding codes. + void setPass(int index, Pass* pass); + + const std::vector& getParameters() const { return _parameters; } const Vector& getPasses() const { return _passes; } uint32_t getStageIDs() const { return _stageIDs; } - // TODO: add get functions - const std::vector& getParameters() const { return _parameters; } - private: static uint32_t _genID; diff --git a/native/cocos/scripting/js-bindings/auto/jsb_renderer_auto.cpp b/native/cocos/scripting/js-bindings/auto/jsb_renderer_auto.cpp index 5f78c17d10..e7864ddf03 100644 --- a/native/cocos/scripting/js-bindings/auto/jsb_renderer_auto.cpp +++ b/native/cocos/scripting/js-bindings/auto/jsb_renderer_auto.cpp @@ -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 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(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(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; } diff --git a/native/cocos/scripting/js-bindings/auto/jsb_renderer_auto.hpp b/native/cocos/scripting/js-bindings/auto/jsb_renderer_auto.hpp index d5b188ebf8..874d39700a 100644 --- a/native/cocos/scripting/js-bindings/auto/jsb_renderer_auto.hpp +++ b/native/cocos/scripting/js-bindings/auto/jsb_renderer_auto.hpp @@ -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); + diff --git a/native/cocos/scripting/js-bindings/jswrapper/jsc/Object.mm b/native/cocos/scripting/js-bindings/jswrapper/jsc/Object.mm index 5a3c563be6..b566e9046f 100644 --- a/native/cocos/scripting/js-bindings/jswrapper/jsc/Object.mm +++ b/native/cocos/scripting/js-bindings/jswrapper/jsc/Object.mm @@ -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; diff --git a/native/cocos/scripting/js-bindings/manual/jsb_cocos2dx_manual.cpp b/native/cocos/scripting/js-bindings/manual/jsb_cocos2dx_manual.cpp index 6fd4482589..704eb53036 100644 --- a/native/cocos/scripting/js-bindings/manual/jsb_cocos2dx_manual.cpp +++ b/native/cocos/scripting/js-bindings/manual/jsb_cocos2dx_manual.cpp @@ -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); \ diff --git a/native/cocos/scripting/js-bindings/manual/jsb_conversions.cpp b/native/cocos/scripting/js-bindings/manual/jsb_conversions.cpp index c84079ab1a..887f44f6ad 100644 --- a/native/cocos/scripting/js-bindings/manual/jsb_conversions.cpp +++ b/native/cocos/scripting/js-bindings/manual/jsb_conversions.cpp @@ -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::vectorgetType(); + 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 textures; cocos2d::renderer::Texture* texture = nullptr; - std::vector keys; - obj->getAllKeys(&keys); - for (auto& key: keys) - { - SE_LOGD("key: %s\n", key.c_str()); - } +// std::vector 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(texArray[0], &val); arr->setArrayElement(i, val); } -// obj->setProperty("val", se::Value(arr)); ret->setObject(arr); } else { se::Value val; native_ptr_to_seval(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; } diff --git a/native/cocos/scripting/js-bindings/manual/jsb_conversions.hpp b/native/cocos/scripting/js-bindings/manual/jsb_conversions.hpp index edb6487c25..f79b74c1e2 100644 --- a/native/cocos/scripting/js-bindings/manual/jsb_conversions.hpp +++ b/native/cocos/scripting/js-bindings/manual/jsb_conversions.hpp @@ -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* ret); bool seval_to_EffectDefineTemplate(const se::Value& v, std::vector* 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* ret); bool seval_to_std_vector_ProgramLib_Template(const se::Value& v, std::vector* ret); diff --git a/native/cocos/scripting/js-bindings/manual/jsb_global.cpp b/native/cocos/scripting/js-bindings/manual/jsb_global.cpp index 5395ab76bf..a556ba15b7 100644 --- a/native/cocos/scripting/js-bindings/manual/jsb_global.cpp +++ b/native/cocos/scripting/js-bindings/manual/jsb_global.cpp @@ -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()); diff --git a/native/cocos/scripting/js-bindings/manual/jsb_renderer_manual.cpp b/native/cocos/scripting/js-bindings/manual/jsb_renderer_manual.cpp index a7c1678a40..ebd1fa87b6 100644 --- a/native/cocos/scripting/js-bindings/manual/jsb_renderer_manual.cpp +++ b/native/cocos/scripting/js-bindings/manual/jsb_renderer_manual.cpp @@ -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(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(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(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; } diff --git a/native/tools/tojs/renderer.ini b/native/tools/tojs/renderer.ini index d181f86bd4..7cf1e6ae56 100644 --- a/native/tools/tojs/renderer.ini +++ b/native/tools/tojs/renderer.ini @@ -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]