diff --git a/native/cocos/platform/CCCanvasRenderingContext2D.h b/native/cocos/platform/CCCanvasRenderingContext2D.h index b1b54b45f1..1f5442a716 100644 --- a/native/cocos/platform/CCCanvasRenderingContext2D.h +++ b/native/cocos/platform/CCCanvasRenderingContext2D.h @@ -57,7 +57,7 @@ public: ~CanvasRenderingContext2D(); void clearRect(float x, float y, float width, float height); - Data getImageData(float sx, float sy, float sw, float sh); +// Data getImageData(float sx, float sy, float sw, float sh); void fillText(const std::string& text, float x, float y, float maxWidth = -1.0f); void strokeText(const std::string& text, float x, float y, float maxWidth = -1.0f); Size measureText(const std::string& text); @@ -71,6 +71,10 @@ public: void stroke(); void restore(); + // callback + using CanvasBufferUpdatedCallback = std::function; + void setCanvasBufferUpdatedCallback(const CanvasBufferUpdatedCallback& cb); + // functions for properties void set__width(float width); void set__height(float height); @@ -109,6 +113,7 @@ public: private: + CanvasBufferUpdatedCallback _canvasBufferUpdatedCB = nullptr; CanvasRenderingContext2DImpl* _impl = nullptr; bool _isBufferSizeDirty = true; diff --git a/native/cocos/platform/mac/CCCanvasRenderingContext2D-mac.mm b/native/cocos/platform/mac/CCCanvasRenderingContext2D-mac.mm index f7f966df11..7a885dc07d 100644 --- a/native/cocos/platform/mac/CCCanvasRenderingContext2D-mac.mm +++ b/native/cocos/platform/mac/CCCanvasRenderingContext2D-mac.mm @@ -7,16 +7,35 @@ #include +enum class CanvasTextAlign { + LEFT, + CENTER, + RIGHT +}; + +enum class CanvasTextBaseline { + TOP, + MIDDLE, + BOTTOM +}; + @interface CanvasRenderingContext2DImpl : NSObject { NSFont* _font; NSMutableDictionary* _tokenAttributesDict; NSString* _fontName; CGFloat _fontSize; + NSImage* _image; + cocos2d::Data _imageData; + CanvasTextAlign _textAlign; + CanvasTextBaseline _textBaseLine; } @property (nonatomic, strong) NSFont* font; @property (nonatomic, strong) NSMutableDictionary* tokenAttributesDict; @property (nonatomic, strong) NSString* fontName; +@property (nonatomic, strong) NSImage* image; +@property (nonatomic, assign) CanvasTextAlign textAlign;; +@property (nonatomic, assign) CanvasTextBaseline textBaseLine;; @end @@ -25,9 +44,14 @@ @synthesize font = _font; @synthesize tokenAttributesDict = _tokenAttributesDict; @synthesize fontName = _fontName; +@synthesize image = _image; +@synthesize textAlign = _textAlign; +@synthesize textBaseLine = _textBaseLine; -(id) init { if ([super init]) { + _textAlign = CanvasTextAlign::LEFT; + _textBaseLine = CanvasTextBaseline::BOTTOM; [self updateFontWithName:@"Arial" fontSize:30]; } @@ -38,6 +62,7 @@ self.font = nil; self.tokenAttributesDict = nil; self.fontName = nil; + self.image = nil; [super dealloc]; } @@ -69,6 +94,7 @@ NSMutableParagraphStyle* paragraphStyle = [[[NSMutableParagraphStyle alloc] init] autorelease]; paragraphStyle.lineBreakMode = NSLineBreakByTruncatingTail; + [paragraphStyle setAlignment:NSTextAlignmentCenter]; // color NSColor* foregroundColor = [NSColor colorWithRed:1.0f @@ -83,8 +109,8 @@ paragraphStyle, NSParagraphStyleAttributeName, nil]; } --(void) updateTextAlignment:(NSTextAlignment) alignment { - +-(void) recreateBufferWithWidth:(NSInteger) width height:(NSInteger) height { + self.image = [[NSImage alloc] initWithSize:NSMakeSize(width, height)]; } -(NSSize) measureText:(NSString*) text { @@ -114,43 +140,67 @@ return dim; } --(void) fillText:(NSString*) text x:(NSInteger) x y:(NSInteger) y width:(NSInteger) width height:(NSInteger) height { -// CGFloat xPadding = 0; -// CGFloat yPadding = 0; -// -// NSInteger POTWide = width; -// NSInteger POTHigh = height; -// NSRect textRect = NSMakeRect(0, 0, -// width, height); -// -// -// [[NSGraphicsContext currentContext] setShouldAntialias:NO]; -// -// NSImage *image = [[NSImage alloc] initWithSize:NSMakeSize(POTWide, POTHigh)]; -// [image lockFocus]; -// // patch for mac retina display and lableTTF -// [[NSAffineTransform transform] set]; -// NSAttributedString *stringWithAttributes =[[[NSAttributedString alloc] initWithString:text -// attributes:_tokenAttributesDict] autorelease]; -// [stringWithAttributes drawInRect:textRect]; -// NSBitmapImageRep *bitmap = [[NSBitmapImageRep alloc] initWithFocusedViewRect:NSMakeRect (0.0f, 0.0f, POTWide, POTHigh)]; -// [image unlockFocus]; -// -// auto data = (unsigned char*) [bitmap bitmapData]; //Use the same buffer to improve the performance. -// -// NSUInteger textureSize = POTWide * POTHigh * 4; -// auto dataNew = (unsigned char*)malloc(sizeof(unsigned char) * textureSize); -// if (dataNew) { -// memcpy(dataNew, data, textureSize); -// // output params -// info->width = static_cast(POTWide); -// info->height = static_cast(POTHigh); -// info->data = dataNew; -// info->isPremultipliedAlpha = true; -// ret = true; -// } -// [bitmap release]; -// [image release]; +-(NSPoint) convertDrawPoint:(NSPoint) point text:(NSString*) text { + NSSize textSize = [self measureText:text]; + NSLog(@"textSize: %f, %f", textSize.width, textSize.height); + + if (_textAlign == CanvasTextAlign::CENTER) + { + point.x -= textSize.width / 2; + } + else if (_textAlign == CanvasTextAlign::RIGHT) + { + point.x -= textSize.width; + } + + if (_textBaseLine == CanvasTextBaseline::TOP) + { + point.y += textSize.height; + } + else if (_textBaseLine == CanvasTextBaseline::MIDDLE) + { + point.y += textSize.height / 2; + } + + return point; +} + +-(void) fillText:(NSString*) text x:(CGFloat) x y:(CGFloat) y maxWidth:(CGFloat) maxWidth { + + NSPoint drawPoint = [self convertDrawPoint:NSMakePoint(x, y) text:text]; + + NSMutableParagraphStyle* paragraphStyle = [[[NSMutableParagraphStyle alloc] init] autorelease]; + paragraphStyle.lineBreakMode = NSLineBreakByTruncatingTail; + + [_tokenAttributesDict setObject:paragraphStyle forKey:NSParagraphStyleAttributeName]; + + [[NSGraphicsContext currentContext] setShouldAntialias:NO]; + + [_image lockFocus]; + // patch for mac retina display and lableTTF + [[NSAffineTransform transform] set]; + NSAttributedString *stringWithAttributes =[[[NSAttributedString alloc] initWithString:text + attributes:_tokenAttributesDict] autorelease]; + + drawPoint.y = _image.size.height - drawPoint.y; + [stringWithAttributes drawAtPoint:drawPoint]; + + NSBitmapImageRep *bitmap = [[NSBitmapImageRep alloc] initWithFocusedViewRect:NSMakeRect (0.0f, 0.0f, _image.size.width, _image.size.height)]; + [_image unlockFocus]; + + unsigned char* data = [bitmap bitmapData]; //Use the same buffer to improve the performance. + + NSUInteger textureSize = _image.size.width * _image.size.height * 4; + uint8_t* buffer = (uint8_t*)malloc(sizeof(uint8_t) * textureSize); + if (buffer) { + memcpy(buffer, data, textureSize); + _imageData.fastSet(buffer, textureSize); + } + [bitmap release]; +} + +-(const cocos2d::Data&) getDataRef { + return _imageData; } @end @@ -185,11 +235,13 @@ CanvasRenderingContext2D::CanvasRenderingContext2D(float width, float height) CanvasRenderingContext2D::~CanvasRenderingContext2D() { SE_LOGD("CanvasGradient destructor: %p\n", this); + [_impl release]; } void CanvasRenderingContext2D::recreateBuffer() { _isBufferSizeDirty = false; + [_impl recreateBufferWithWidth: __width height:__height]; } void CanvasRenderingContext2D::clearRect(float x, float y, float width, float height) @@ -197,17 +249,23 @@ void CanvasRenderingContext2D::clearRect(float x, float y, float width, float he SE_LOGD("CanvasGradient::clearRect: %p, %f, %f, %f, %f\n", this, x, y, width, height); } -Data CanvasRenderingContext2D::getImageData(float sx, float sy, float sw, float sh) -{ - SE_LOGD("CanvasGradient::getImageData: %p, %f, %f, %f, %f\n", this, sx, sy, sw, sh); - return Data(); -} +//Data CanvasRenderingContext2D::getImageData(float sx, float sy, float sw, float sh) +//{ +// SE_LOGD("CanvasGradient::getImageData: %p, %f, %f, %f, %f\n", this, sx, sy, sw, sh); +// assert(sx == 0 && sy == 0 && sw == __width && sh == __height); // TODO: cjh +// +// return [_impl getImageData]; +//} 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); if (_isBufferSizeDirty) recreateBuffer(); + + [_impl fillText:[NSString stringWithUTF8String:text.c_str()] x:x y:y maxWidth:maxWidth]; + if (_canvasBufferUpdatedCB != nullptr) + _canvasBufferUpdatedCB([_impl getDataRef]); } void CanvasRenderingContext2D::strokeText(const std::string& text, float x, float y, float maxWidth) @@ -215,6 +273,9 @@ void CanvasRenderingContext2D::strokeText(const std::string& text, float x, floa SE_LOGD("CanvasRenderingContext2D::strokeText: %s, %f, %f, %f\n", text.c_str(), x, y, maxWidth); if (_isBufferSizeDirty) recreateBuffer(); + + if (_canvasBufferUpdatedCB != nullptr) + _canvasBufferUpdatedCB([_impl getDataRef]); } cocos2d::Size CanvasRenderingContext2D::measureText(const std::string& text) @@ -264,6 +325,11 @@ void CanvasRenderingContext2D::restore() } +void CanvasRenderingContext2D::setCanvasBufferUpdatedCallback(const CanvasBufferUpdatedCallback& cb) +{ + _canvasBufferUpdatedCB = cb; +} + void CanvasRenderingContext2D::set__width(float width) { SE_LOGD("CanvasRenderingContext2D::set__width: %f\n", width); @@ -294,15 +360,18 @@ void CanvasRenderingContext2D::set_font(const std::string& font) { _font = font; + // TODO: cjh implements bold + std::string bold; std::string fontName = "Arial"; std::string fontSizeStr = "30"; - std::regex re("(\\d+)px\\s+(\\w+)"); + std::regex re("(bold)?\\s*(\\d+)px\\s+(\\w+)"); std::match_results results; if (std::regex_search(_font.cbegin(), _font.cend(), results, re)) { - fontName = results[2].str(); - fontSizeStr = results[1].str(); + bold = results[1].str(); + fontSizeStr = results[2].str(); + fontName = results[3].str(); } CGFloat fontSize = atof(fontSizeStr.c_str()); @@ -313,11 +382,43 @@ 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()); + if (textAlign == "left") + { + _impl.textAlign = CanvasTextAlign::LEFT; + } + else if (textAlign == "center") + { + _impl.textAlign = CanvasTextAlign::CENTER; + } + else if (textAlign == "right") + { + _impl.textAlign = CanvasTextAlign::RIGHT; + } + else + { + assert(false); + } } void CanvasRenderingContext2D::set_textBaseline(const std::string& textBaseline) { SE_LOGD("CanvasRenderingContext2D::set_textBaseline: %s\n", textBaseline.c_str()); + if (textBaseline == "top") + { + _impl.textBaseLine = CanvasTextBaseline::TOP; + } + else if (textBaseline == "middle") + { + _impl.textBaseLine = CanvasTextBaseline::MIDDLE; + } + else if (textBaseline == "bottom") + { + _impl.textBaseLine = CanvasTextBaseline::BOTTOM; + } + else + { + assert(false); + } } void CanvasRenderingContext2D::set_fillStyle(const std::string& fillStyle) diff --git a/native/cocos/scripting/js-bindings/auto/api/jsb_cocos2dx_auto_api.js b/native/cocos/scripting/js-bindings/auto/api/jsb_cocos2dx_auto_api.js index 6e11e19f74..4c73d493ea 100644 --- a/native/cocos/scripting/js-bindings/auto/api/jsb_cocos2dx_auto_api.js +++ b/native/cocos/scripting/js-bindings/auto/api/jsb_cocos2dx_auto_api.js @@ -540,14 +540,6 @@ float { }, -/** - * @method beginPath - */ -beginPath : function ( -) -{ -}, - /** * @method lineTo * @param {float} arg0 @@ -561,39 +553,39 @@ float }, /** - * @method getImageData - * @param {float} arg0 - * @param {float} arg1 - * @param {float} arg2 - * @param {float} arg3 - * @return {cc.Data} + * @method stroke */ -getImageData : function ( -float, -float, -float, -float +stroke : function ( ) { - return cc.Data; }, /** - * @method createLinearGradient + * @method measureText + * @param {String} arg0 + * @return {size_object} + */ +measureText : function ( +str +) +{ + return cc.Size; +}, + +/** + * @method clearRect * @param {float} arg0 * @param {float} arg1 * @param {float} arg2 * @param {float} arg3 - * @return {cc.CanvasGradient} */ -createLinearGradient : function ( +clearRect : function ( float, float, float, float ) { - return cc.CanvasGradient; }, /** @@ -612,14 +604,6 @@ float { }, -/** - * @method stroke - */ -stroke : function ( -) -{ -}, - /** * @method strokeText * @param {String} arg0 @@ -636,26 +620,6 @@ float { }, -/** - * @method measureText - * @param {String} arg0 - * @return {size_object} - */ -measureText : function ( -str -) -{ - return cc.Size; -}, - -/** - * @method closePath - */ -closePath : function ( -) -{ -}, - /** * @method save */ @@ -665,18 +629,36 @@ save : function ( }, /** - * @method clearRect + * @method beginPath + */ +beginPath : function ( +) +{ +}, + +/** + * @method createLinearGradient * @param {float} arg0 * @param {float} arg1 * @param {float} arg2 * @param {float} arg3 + * @return {cc.CanvasGradient} */ -clearRect : function ( +createLinearGradient : function ( float, float, float, float ) +{ + return cc.CanvasGradient; +}, + +/** + * @method closePath + */ +closePath : function ( +) { }, diff --git a/native/cocos/scripting/js-bindings/auto/jsb_cocos2dx_auto.cpp b/native/cocos/scripting/js-bindings/auto/jsb_cocos2dx_auto.cpp index 355cd8f8cc..811211b0af 100644 --- a/native/cocos/scripting/js-bindings/auto/jsb_cocos2dx_auto.cpp +++ b/native/cocos/scripting/js-bindings/auto/jsb_cocos2dx_auto.cpp @@ -1057,21 +1057,6 @@ static bool js_cocos2dx_CanvasRenderingContext2D_moveTo(se::State& s) } SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_moveTo) -static bool js_cocos2dx_CanvasRenderingContext2D_beginPath(se::State& s) -{ - cocos2d::CanvasRenderingContext2D* cobj = (cocos2d::CanvasRenderingContext2D*)s.nativeThisObject(); - SE_PRECONDITION2(cobj, false, "js_cocos2dx_CanvasRenderingContext2D_beginPath : Invalid Native Object"); - const auto& args = s.args(); - size_t argc = args.size(); - if (argc == 0) { - cobj->beginPath(); - return true; - } - SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); - return false; -} -SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_beginPath) - static bool js_cocos2dx_CanvasRenderingContext2D_lineTo(se::State& s) { cocos2d::CanvasRenderingContext2D* cobj = (cocos2d::CanvasRenderingContext2D*)s.nativeThisObject(); @@ -1093,37 +1078,46 @@ static bool js_cocos2dx_CanvasRenderingContext2D_lineTo(se::State& s) } SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_lineTo) -static bool js_cocos2dx_CanvasRenderingContext2D_getImageData(se::State& s) +static bool js_cocos2dx_CanvasRenderingContext2D_stroke(se::State& s) { cocos2d::CanvasRenderingContext2D* cobj = (cocos2d::CanvasRenderingContext2D*)s.nativeThisObject(); - SE_PRECONDITION2(cobj, false, "js_cocos2dx_CanvasRenderingContext2D_getImageData : Invalid Native Object"); + SE_PRECONDITION2(cobj, false, "js_cocos2dx_CanvasRenderingContext2D_stroke : Invalid Native Object"); const auto& args = s.args(); size_t argc = args.size(); - CC_UNUSED bool ok = true; - if (argc == 4) { - float arg0 = 0; - float arg1 = 0; - float arg2 = 0; - float arg3 = 0; - ok &= seval_to_float(args[0], &arg0); - ok &= seval_to_float(args[1], &arg1); - ok &= seval_to_float(args[2], &arg2); - ok &= seval_to_float(args[3], &arg3); - SE_PRECONDITION2(ok, false, "js_cocos2dx_CanvasRenderingContext2D_getImageData : Error processing arguments"); - cocos2d::Data result = cobj->getImageData(arg0, arg1, arg2, arg3); - ok &= Data_to_seval(result, &s.rval()); - SE_PRECONDITION2(ok, false, "js_cocos2dx_CanvasRenderingContext2D_getImageData : Error processing arguments"); + if (argc == 0) { + cobj->stroke(); 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, 0); return false; } -SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_getImageData) +SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_stroke) -static bool js_cocos2dx_CanvasRenderingContext2D_createLinearGradient(se::State& s) +static bool js_cocos2dx_CanvasRenderingContext2D_measureText(se::State& s) { cocos2d::CanvasRenderingContext2D* cobj = (cocos2d::CanvasRenderingContext2D*)s.nativeThisObject(); - SE_PRECONDITION2(cobj, false, "js_cocos2dx_CanvasRenderingContext2D_createLinearGradient : Invalid Native Object"); + SE_PRECONDITION2(cobj, false, "js_cocos2dx_CanvasRenderingContext2D_measureText : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + std::string arg0; + ok &= seval_to_std_string(args[0], &arg0); + SE_PRECONDITION2(ok, false, "js_cocos2dx_CanvasRenderingContext2D_measureText : Error processing arguments"); + cocos2d::Size result = cobj->measureText(arg0); + ok &= Size_to_seval(result, &s.rval()); + SE_PRECONDITION2(ok, false, "js_cocos2dx_CanvasRenderingContext2D_measureText : Error processing arguments"); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_measureText) + +static bool js_cocos2dx_CanvasRenderingContext2D_clearRect(se::State& s) +{ + cocos2d::CanvasRenderingContext2D* cobj = (cocos2d::CanvasRenderingContext2D*)s.nativeThisObject(); + SE_PRECONDITION2(cobj, false, "js_cocos2dx_CanvasRenderingContext2D_clearRect : Invalid Native Object"); const auto& args = s.args(); size_t argc = args.size(); CC_UNUSED bool ok = true; @@ -1136,16 +1130,14 @@ static bool js_cocos2dx_CanvasRenderingContext2D_createLinearGradient(se::State& ok &= seval_to_float(args[1], &arg1); ok &= seval_to_float(args[2], &arg2); ok &= seval_to_float(args[3], &arg3); - SE_PRECONDITION2(ok, false, "js_cocos2dx_CanvasRenderingContext2D_createLinearGradient : Error processing arguments"); - cocos2d::CanvasGradient* result = cobj->createLinearGradient(arg0, arg1, arg2, arg3); - ok &= native_ptr_to_seval((cocos2d::CanvasGradient*)result, &s.rval()); - SE_PRECONDITION2(ok, false, "js_cocos2dx_CanvasRenderingContext2D_createLinearGradient : Error processing arguments"); + SE_PRECONDITION2(ok, false, "js_cocos2dx_CanvasRenderingContext2D_clearRect : Error processing arguments"); + cobj->clearRect(arg0, arg1, arg2, arg3); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); return false; } -SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_createLinearGradient) +SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_clearRect) static bool js_cocos2dx_CanvasRenderingContext2D_fillText(se::State& s) { @@ -1183,21 +1175,6 @@ static bool js_cocos2dx_CanvasRenderingContext2D_fillText(se::State& s) } SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_fillText) -static bool js_cocos2dx_CanvasRenderingContext2D_stroke(se::State& s) -{ - cocos2d::CanvasRenderingContext2D* cobj = (cocos2d::CanvasRenderingContext2D*)s.nativeThisObject(); - SE_PRECONDITION2(cobj, false, "js_cocos2dx_CanvasRenderingContext2D_stroke : Invalid Native Object"); - const auto& args = s.args(); - size_t argc = args.size(); - if (argc == 0) { - cobj->stroke(); - return true; - } - SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); - return false; -} -SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_stroke) - static bool js_cocos2dx_CanvasRenderingContext2D_strokeText(se::State& s) { cocos2d::CanvasRenderingContext2D* cobj = (cocos2d::CanvasRenderingContext2D*)s.nativeThisObject(); @@ -1234,42 +1211,6 @@ static bool js_cocos2dx_CanvasRenderingContext2D_strokeText(se::State& s) } SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_strokeText) -static bool js_cocos2dx_CanvasRenderingContext2D_measureText(se::State& s) -{ - cocos2d::CanvasRenderingContext2D* cobj = (cocos2d::CanvasRenderingContext2D*)s.nativeThisObject(); - SE_PRECONDITION2(cobj, false, "js_cocos2dx_CanvasRenderingContext2D_measureText : Invalid Native Object"); - const auto& args = s.args(); - size_t argc = args.size(); - CC_UNUSED bool ok = true; - if (argc == 1) { - std::string arg0; - ok &= seval_to_std_string(args[0], &arg0); - SE_PRECONDITION2(ok, false, "js_cocos2dx_CanvasRenderingContext2D_measureText : Error processing arguments"); - cocos2d::Size result = cobj->measureText(arg0); - ok &= Size_to_seval(result, &s.rval()); - SE_PRECONDITION2(ok, false, "js_cocos2dx_CanvasRenderingContext2D_measureText : Error processing arguments"); - return true; - } - SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); - return false; -} -SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_measureText) - -static bool js_cocos2dx_CanvasRenderingContext2D_closePath(se::State& s) -{ - cocos2d::CanvasRenderingContext2D* cobj = (cocos2d::CanvasRenderingContext2D*)s.nativeThisObject(); - SE_PRECONDITION2(cobj, false, "js_cocos2dx_CanvasRenderingContext2D_closePath : Invalid Native Object"); - const auto& args = s.args(); - size_t argc = args.size(); - if (argc == 0) { - cobj->closePath(); - return true; - } - SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); - return false; -} -SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_closePath) - static bool js_cocos2dx_CanvasRenderingContext2D_save(se::State& s) { cocos2d::CanvasRenderingContext2D* cobj = (cocos2d::CanvasRenderingContext2D*)s.nativeThisObject(); @@ -1285,10 +1226,25 @@ static bool js_cocos2dx_CanvasRenderingContext2D_save(se::State& s) } SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_save) -static bool js_cocos2dx_CanvasRenderingContext2D_clearRect(se::State& s) +static bool js_cocos2dx_CanvasRenderingContext2D_beginPath(se::State& s) { cocos2d::CanvasRenderingContext2D* cobj = (cocos2d::CanvasRenderingContext2D*)s.nativeThisObject(); - SE_PRECONDITION2(cobj, false, "js_cocos2dx_CanvasRenderingContext2D_clearRect : Invalid Native Object"); + SE_PRECONDITION2(cobj, false, "js_cocos2dx_CanvasRenderingContext2D_beginPath : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + if (argc == 0) { + cobj->beginPath(); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; +} +SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_beginPath) + +static bool js_cocos2dx_CanvasRenderingContext2D_createLinearGradient(se::State& s) +{ + cocos2d::CanvasRenderingContext2D* cobj = (cocos2d::CanvasRenderingContext2D*)s.nativeThisObject(); + SE_PRECONDITION2(cobj, false, "js_cocos2dx_CanvasRenderingContext2D_createLinearGradient : Invalid Native Object"); const auto& args = s.args(); size_t argc = args.size(); CC_UNUSED bool ok = true; @@ -1301,14 +1257,31 @@ static bool js_cocos2dx_CanvasRenderingContext2D_clearRect(se::State& s) ok &= seval_to_float(args[1], &arg1); ok &= seval_to_float(args[2], &arg2); ok &= seval_to_float(args[3], &arg3); - SE_PRECONDITION2(ok, false, "js_cocos2dx_CanvasRenderingContext2D_clearRect : Error processing arguments"); - cobj->clearRect(arg0, arg1, arg2, arg3); + SE_PRECONDITION2(ok, false, "js_cocos2dx_CanvasRenderingContext2D_createLinearGradient : Error processing arguments"); + cocos2d::CanvasGradient* result = cobj->createLinearGradient(arg0, arg1, arg2, arg3); + ok &= native_ptr_to_seval((cocos2d::CanvasGradient*)result, &s.rval()); + SE_PRECONDITION2(ok, false, "js_cocos2dx_CanvasRenderingContext2D_createLinearGradient : Error processing arguments"); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 4); return false; } -SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_clearRect) +SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_createLinearGradient) + +static bool js_cocos2dx_CanvasRenderingContext2D_closePath(se::State& s) +{ + cocos2d::CanvasRenderingContext2D* cobj = (cocos2d::CanvasRenderingContext2D*)s.nativeThisObject(); + SE_PRECONDITION2(cobj, false, "js_cocos2dx_CanvasRenderingContext2D_closePath : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + if (argc == 0) { + cobj->closePath(); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; +} +SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_closePath) SE_DECLARE_FINALIZE_FUNC(js_cocos2d_CanvasRenderingContext2D_finalize) @@ -1351,17 +1324,16 @@ bool js_register_cocos2dx_CanvasRenderingContext2D(se::Object* obj) cls->defineFunction("restore", _SE(js_cocos2dx_CanvasRenderingContext2D_restore)); cls->defineFunction("moveTo", _SE(js_cocos2dx_CanvasRenderingContext2D_moveTo)); - cls->defineFunction("beginPath", _SE(js_cocos2dx_CanvasRenderingContext2D_beginPath)); cls->defineFunction("lineTo", _SE(js_cocos2dx_CanvasRenderingContext2D_lineTo)); - cls->defineFunction("_getImageData", _SE(js_cocos2dx_CanvasRenderingContext2D_getImageData)); - cls->defineFunction("createLinearGradient", _SE(js_cocos2dx_CanvasRenderingContext2D_createLinearGradient)); - cls->defineFunction("fillText", _SE(js_cocos2dx_CanvasRenderingContext2D_fillText)); cls->defineFunction("stroke", _SE(js_cocos2dx_CanvasRenderingContext2D_stroke)); - cls->defineFunction("strokeText", _SE(js_cocos2dx_CanvasRenderingContext2D_strokeText)); cls->defineFunction("measureText", _SE(js_cocos2dx_CanvasRenderingContext2D_measureText)); - cls->defineFunction("closePath", _SE(js_cocos2dx_CanvasRenderingContext2D_closePath)); - cls->defineFunction("save", _SE(js_cocos2dx_CanvasRenderingContext2D_save)); cls->defineFunction("clearRect", _SE(js_cocos2dx_CanvasRenderingContext2D_clearRect)); + cls->defineFunction("fillText", _SE(js_cocos2dx_CanvasRenderingContext2D_fillText)); + cls->defineFunction("strokeText", _SE(js_cocos2dx_CanvasRenderingContext2D_strokeText)); + cls->defineFunction("save", _SE(js_cocos2dx_CanvasRenderingContext2D_save)); + cls->defineFunction("beginPath", _SE(js_cocos2dx_CanvasRenderingContext2D_beginPath)); + cls->defineFunction("createLinearGradient", _SE(js_cocos2dx_CanvasRenderingContext2D_createLinearGradient)); + cls->defineFunction("closePath", _SE(js_cocos2dx_CanvasRenderingContext2D_closePath)); cls->defineFinalizeFunction(_SE(js_cocos2d_CanvasRenderingContext2D_finalize)); cls->install(); JSBClassType::registerClass(cls); diff --git a/native/cocos/scripting/js-bindings/auto/jsb_cocos2dx_auto.hpp b/native/cocos/scripting/js-bindings/auto/jsb_cocos2dx_auto.hpp index ee74225463..8caedaf4da 100644 --- a/native/cocos/scripting/js-bindings/auto/jsb_cocos2dx_auto.hpp +++ b/native/cocos/scripting/js-bindings/auto/jsb_cocos2dx_auto.hpp @@ -70,16 +70,15 @@ bool js_register_cocos2d_CanvasRenderingContext2D(se::Object* obj); bool register_all_cocos2dx(se::Object* obj); SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_restore); SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_moveTo); -SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_beginPath); SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_lineTo); -SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_getImageData); -SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_createLinearGradient); -SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_fillText); SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_stroke); -SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_strokeText); SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_measureText); -SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_closePath); -SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_save); SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_clearRect); +SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_fillText); +SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_strokeText); +SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_save); +SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_beginPath); +SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_createLinearGradient); +SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_closePath); SE_DECLARE_FUNC(js_cocos2dx_CanvasRenderingContext2D_CanvasRenderingContext2D); 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 c91878255f..6fd4482589 100644 --- a/native/cocos/scripting/js-bindings/manual/jsb_cocos2dx_manual.cpp +++ b/native/cocos/scripting/js-bindings/manual/jsb_cocos2dx_manual.cpp @@ -357,6 +357,55 @@ BIND_PROP_WITH_TYPE__CONV_FUNC__RETURN(CanvasRenderingContext2D, globalComposite #define _SE_DEFINE_PROP(cls, property) \ __jsb_cocos2d_##cls##_proto->defineProperty(#property, _SE(js_cocos2dx_##cls_get_##property), _SE(js_cocos2dx_##cls_set_##property)); +//FIXME:cjh move to auto bindings. +static bool js_cocos2dx_CanvasRenderingContext2D_setCanvasBufferUpdatedCallback(se::State& s) +{ + cocos2d::CanvasRenderingContext2D* cobj = (cocos2d::CanvasRenderingContext2D*)s.nativeThisObject(); + SE_PRECONDITION2(cobj, false, "js_cocos2dx_CanvasRenderingContext2D_setCanvasBufferUpdatedCallback : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + CC_UNUSED bool ok = true; + if (argc == 1) { + std::function arg0; + do { + if (args[0].isObject() && args[0].toObject()->isFunction()) + { + se::Value jsThis(s.thisObject()); + se::Value jsFunc(args[0]); + jsThis.toObject()->attachObject(jsFunc.toObject()); + auto lambda = [=](const cocos2d::Data & larg0) -> void { + se::ScriptEngine::getInstance()->clearException(); + se::AutoHandleScope hs; + + CC_UNUSED bool ok = true; + se::ValueArray args; + args.resize(1); + ok &= Data_to_seval(larg0, &args[0]); + se::Value rval; + se::Object* thisObj = jsThis.isObject() ? jsThis.toObject() : nullptr; + se::Object* funcObj = jsFunc.toObject(); + bool succeed = funcObj->call(args, thisObj, &rval); + if (!succeed) { + se::ScriptEngine::getInstance()->clearException(); + } + }; + arg0 = lambda; + } + else + { + arg0 = nullptr; + } + } while(false) + ; + SE_PRECONDITION2(ok, false, "js_cocos2dx_CanvasRenderingContext2D_setCanvasBufferUpdatedCallback : Error processing arguments"); + cobj->setCanvasBufferUpdatedCallback(arg0); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); + return false; +} +SE_BIND_FUNC(js_cocos2dx_CanvasRenderingContext2D_setCanvasBufferUpdatedCallback) + static bool register_canvas_context2d(se::Object* obj) { _SE_DEFINE_PROP(CanvasRenderingContext2D, _width) @@ -370,6 +419,8 @@ static bool register_canvas_context2d(se::Object* obj) _SE_DEFINE_PROP(CanvasRenderingContext2D, strokeStyle) _SE_DEFINE_PROP(CanvasRenderingContext2D, globalCompositeOperation) + __jsb_cocos2d_CanvasRenderingContext2D_proto->defineFunction("setCanvasBufferUpdatedCallback", _SE(js_cocos2dx_CanvasRenderingContext2D_setCanvasBufferUpdatedCallback)); + se::ScriptEngine::getInstance()->clearException(); return true; diff --git a/native/tools/tojs/cocos2dx.ini b/native/tools/tojs/cocos2dx.ini index 8e564e2e6d..cc3e05843c 100644 --- a/native/tools/tojs/cocos2dx.ini +++ b/native/tools/tojs/cocos2dx.ini @@ -44,7 +44,8 @@ field = # functions from all classes. skip = FileUtils::[getFileData setFilenameLookupDictionary destroyInstance getFullPathCache getContents], - SAXParser::[(?!(init))] + SAXParser::[(?!(init))], + CanvasRenderingContext2D::[setCanvasBufferUpdatedCallback set_.+] rename_functions = FileUtils::[loadFilenameLookupDictionaryFromFile=loadFilenameLookup], CanvasRenderingContext2D::[getImageData=_getImageData]