From ceab8ce28b3ad8b2f8d3b28bbf2c400c85402ba4 Mon Sep 17 00:00:00 2001 From: Joshua Granick Date: Fri, 1 May 2015 12:25:53 -0700 Subject: [PATCH] More work on Cairo bindings --- lime/graphics/CairoRenderContext.hx | 2 + lime/graphics/cairo/Cairo.hx | 432 +++++++++++++++++- lime/graphics/cairo/CairoContent.hx | 10 + lime/graphics/cairo/CairoExtend.hx | 11 + lime/graphics/cairo/CairoFilter.hx | 13 + lime/graphics/cairo/CairoLineCap.hx | 10 + lime/graphics/cairo/CairoLineJoin.hx | 10 + lime/graphics/cairo/CairoOperator.hx | 36 ++ lime/graphics/cairo/CairoPattern.hx | 132 ++++++ lime/graphics/cairo/CairoSurface.hx | 45 +- project/Build.xml | 1 + project/include/math/Matrix3.h | 36 ++ project/include/math/Rectangle.h | 1 + project/src/graphics/cairo/CairoBindings.cpp | 449 +++++++++++++++++++ project/src/math/Matrix3.cpp | 78 ++++ project/src/math/Rectangle.cpp | 10 + 16 files changed, 1271 insertions(+), 5 deletions(-) create mode 100644 lime/graphics/cairo/CairoContent.hx create mode 100644 lime/graphics/cairo/CairoExtend.hx create mode 100644 lime/graphics/cairo/CairoFilter.hx create mode 100644 lime/graphics/cairo/CairoLineCap.hx create mode 100644 lime/graphics/cairo/CairoLineJoin.hx create mode 100644 lime/graphics/cairo/CairoOperator.hx create mode 100644 lime/graphics/cairo/CairoPattern.hx create mode 100644 project/include/math/Matrix3.h create mode 100644 project/src/math/Matrix3.cpp diff --git a/lime/graphics/CairoRenderContext.hx b/lime/graphics/CairoRenderContext.hx index 9c5437ed5..e5a375e66 100644 --- a/lime/graphics/CairoRenderContext.hx +++ b/lime/graphics/CairoRenderContext.hx @@ -2,6 +2,8 @@ package lime.graphics; import lime.graphics.cairo.Cairo; +import lime.graphics.cairo.CairoFormat; +import lime.graphics.cairo.CairoSurface; class CairoRenderContext { diff --git a/lime/graphics/cairo/Cairo.hx b/lime/graphics/cairo/Cairo.hx index 08ecd7d59..be9cc9f50 100644 --- a/lime/graphics/cairo/Cairo.hx +++ b/lime/graphics/cairo/Cairo.hx @@ -1,6 +1,7 @@ package lime.graphics.cairo; +import lime.math.Matrix3; import lime.system.System; @@ -10,11 +11,133 @@ class Cairo { public static var version (get, null):Int; public static var versionString (get, null):String; + public var lineCap (get, set):CairoLineCap; + public var lineJoin (get, set):CairoLineJoin; + public var lineWidth (get, set):Float; + public var matrix (get, set):Matrix3; + public var miterLimit (get, set):Float; + public var operator (get, set):CairoOperator; + public var source (get, set):CairoPattern; - public static function imageSurfaceCreate (format:CairoFormat, width:Int, height:Int):CairoSurface { + private var handle:Dynamic; + + + public function new (surface:CairoSurface = null):Void { + + if (surface != null) { + + #if lime_cairo + handle = lime_cairo_create (surface); + #end + + } + + } + + + public function clip ():Void { #if lime_cairo - return lime_cairo_image_surface_create (format, width, height); + lime_cairo_clip (handle); + #end + + } + + + public function closePath ():Void { + + #if lime_cairo + lime_cairo_close_path (handle); + #end + + } + + + public function destroy ():Void { + + #if lime_cairo + lime_cairo_destroy (handle); + #end + + } + + + public function fill ():Void { + + #if lime_cairo + lime_cairo_fill (handle); + #end + + } + + + public function fillPreserve ():Void { + + #if lime_cairo + lime_cairo_fill_preserve (handle); + #end + + } + + + public function lineTo (x:Float, y:Float):Void { + + #if lime_cairo + lime_cairo_line_to (handle, x, y); + #end + + } + + + public function moveTo (x:Float, y:Float):Void { + + #if lime_cairo + lime_cairo_move_to (handle, x, y); + #end + + } + + + public function mask (pattern:CairoPattern):Void { + + #if lime_cairo + lime_cairo_mask (handle, pattern); + #end + + } + + + public function newPath ():Void { + + #if lime_cairo + lime_cairo_new_path (handle); + #end + + } + + + public function paint ():Void { + + #if lime_cairo + lime_cairo_paint (handle); + #end + + } + + + public function paintWithAlpha (alpha:Float):Void { + + #if lime_cairo + lime_cairo_paint_with_alpha (handle, alpha); + #end + + } + + + public function popGroup ():CairoPattern { + + #if lime_cairo + return lime_cairo_pop_group (handle); #else return null; #end @@ -22,11 +145,276 @@ class Cairo { } + public function popGroupToSource ():Void { + + #if lime_cairo + lime_cairo_pop_group_to_source (handle); + #end + + } + + + public function pushGroup ():Void { + + #if lime_cairo + lime_cairo_push_group (handle); + #end + + } + + + public function pushGroupWithContent (content:CairoContent):Void { + + #if lime_cairo + lime_cairo_push_group_with_content (handle, content); + #end + + } + + + public function rectangle (x:Float, y:Float, width:Float, height:Float):Void { + + #if lime_cairo + lime_cairo_rectangle (handle, x, y, width, height); + #end + + } + + + public function resetClip ():Void { + + #if lime_cairo + lime_cairo_reset_clip (handle); + #end + + } + + + public function restore ():Void { + + #if lime_cairo + lime_cairo_restore (handle); + #end + + } + + + public function save ():Void { + + #if lime_cairo + lime_cairo_save (handle); + #end + + } + + + public function setSourceRGBA (r:Float, g:Float, b:Float, a:Float):Void { + + #if lime_cairo + lime_cairo_set_source_rgba (handle, r, g, b, a); + #end + + } + + + public function setSourceSurface (surface:CairoSurface, x:Float, y:Float):Void { + + #if lime_cairo + lime_cairo_set_source_surface (handle, surface, x, y); + #end + + } + + + public function stroke ():Void { + + #if lime_cairo + lime_cairo_stroke (handle); + #end + + } + + + public function strokePreserve ():Void { + + #if lime_cairo + lime_cairo_stroke_preserve (handle); + #end + + } + + + public function transform (matrix:Matrix3):Void { + + #if lime_cairo + lime_cairo_transform (handle, matrix); + #end + + } + + + + // Get & Set Methods + private function get_lineCap ():CairoLineCap { + + #if lime_cairo + return lime_cairo_get_line_cap (handle); + #end + + return 0; + + } + + + private function set_lineCap (value:CairoLineCap):CairoLineCap { + + #if lime_cairo + lime_cairo_set_line_cap (handle, value); + #end + + return value; + + } + + + private function get_lineJoin ():CairoLineJoin { + + #if lime_cairo + return lime_cairo_get_line_join (handle); + #end + + return 0; + + } + + + private function set_lineJoin (value:CairoLineJoin):CairoLineJoin { + + #if lime_cairo + lime_cairo_set_line_join (handle, value); + #end + + return value; + + } + + + private function get_lineWidth ():Float { + + #if lime_cairo + return lime_cairo_get_line_width (handle); + #end + + return 0; + + } + + + private function set_lineWidth (value:Float):Float { + + #if lime_cairo + lime_cairo_set_line_width (handle, value); + #end + + return value; + + } + + + private function get_matrix ():Matrix3 { + + #if lime_cairo + var m = lime_cairo_get_matrix (handle); + return new Matrix3 (m.a, m.b, m.c, m.d, m.tx, m.ty); + #end + + return null; + + } + + + private function set_matrix (value:Matrix3):Matrix3 { + + #if lime_cairo + lime_cairo_set_matrix (handle, value); + #end + + return value; + + } + + + private function get_miterLimit ():Float { + + #if lime_cairo + return lime_cairo_get_miter_limit (handle); + #end + + return 0; + + } + + + private function set_miterLimit (value:Float):Float { + + #if lime_cairo + lime_cairo_set_miter_limit (handle, value); + #end + + return value; + + } + + + private function get_operator ():CairoOperator { + + #if lime_cairo + return lime_cairo_get_operator (handle); + #end + + return cast 0; + + } + + + private function set_operator (value:CairoOperator):CairoOperator { + + #if lime_cairo + lime_cairo_set_operator (handle, value); + #end + + return value; + + } + + + private function get_source ():CairoPattern { + + #if lime_cairo + return lime_cairo_get_source (handle); + #end + + return cast 0; + + } + + + private function set_source (value:CairoPattern):CairoPattern { + + #if lime_cairo + lime_cairo_set_source (handle, value); + #end + + return value; + + } + + private static function get_version ():Int { #if lime_cairo @@ -57,7 +445,45 @@ class Cairo { #if lime_cairo - private static var lime_cairo_image_surface_create = System.load ("lime", "lime_cairo_image_surface_create", 3); + private static var lime_cairo_clip = System.load ("lime", "lime_cairo_clip", 1); + private static var lime_cairo_close_path = System.load ("lime", "lime_cairo_close_path", 1); + private static var lime_cairo_create = System.load ("lime", "lime_cairo_create", 1); + private static var lime_cairo_destroy = System.load ("lime", "lime_cairo_destroy", 1); + private static var lime_cairo_fill = System.load ("lime", "lime_cairo_fill", 1); + private static var lime_cairo_fill_preserve = System.load ("lime", "lime_cairo_fill_preserve", 1); + private static var lime_cairo_get_line_cap = System.load ("lime", "lime_cairo_get_line_cap", 1); + private static var lime_cairo_get_line_join = System.load ("lime", "lime_cairo_get_line_join", 1); + private static var lime_cairo_get_line_width = System.load ("lime", "lime_cairo_get_line_width", 1); + private static var lime_cairo_get_matrix = System.load ("lime", "lime_cairo_get_matrix", 1); + private static var lime_cairo_get_miter_limit = System.load ("lime", "lime_cairo_get_miter_limit", 1); + private static var lime_cairo_get_operator = System.load ("lime", "lime_cairo_get_operator", 1); + private static var lime_cairo_get_source = System.load ("lime", "lime_cairo_get_source", 1); + private static var lime_cairo_line_to = System.load ("lime", "lime_cairo_line_to", 3); + private static var lime_cairo_mask = System.load ("lime", "lime_cairo_mask", 2); + private static var lime_cairo_move_to = System.load ("lime", "lime_cairo_move_to", 3); + private static var lime_cairo_new_path = System.load ("lime", "lime_cairo_new_path", 1); + private static var lime_cairo_paint = System.load ("lime", "lime_cairo_paint", 1); + private static var lime_cairo_paint_with_alpha = System.load ("lime", "lime_cairo_paint_with_alpha", 2); + private static var lime_cairo_pop_group = System.load ("lime", "lime_cairo_pop_group", 1); + private static var lime_cairo_pop_group_to_source = System.load ("lime", "lime_cairo_pop_group_to_source", 1); + private static var lime_cairo_push_group = System.load ("lime", "lime_cairo_push_group", 1); + private static var lime_cairo_push_group_with_content = System.load ("lime", "lime_cairo_push_group_with_content", 2); + private static var lime_cairo_rectangle = System.load ("lime", "lime_cairo_rectangle", 5); + private static var lime_cairo_reset_clip = System.load ("lime", "lime_cairo_reset_clip", 1); + private static var lime_cairo_restore = System.load ("lime", "lime_cairo_restore", 1); + private static var lime_cairo_save = System.load ("lime", "lime_cairo_save", 1); + private static var lime_cairo_set_line_cap = System.load ("lime", "lime_cairo_set_line_cap", 2); + private static var lime_cairo_set_line_join = System.load ("lime", "lime_cairo_set_line_join", 2); + private static var lime_cairo_set_line_width = System.load ("lime", "lime_cairo_set_line_width", 2); + private static var lime_cairo_set_matrix = System.load ("lime", "lime_cairo_set_matrix", 2); + private static var lime_cairo_set_miter_limit = System.load ("lime", "lime_cairo_set_miter_limit", 2); + private static var lime_cairo_set_operator = System.load ("lime", "lime_cairo_set_operator", 2); + private static var lime_cairo_set_source = System.load ("lime", "lime_cairo_set_source", 2); + private static var lime_cairo_set_source_rgba = System.load ("lime", "lime_cairo_set_source_rgba", 5); + private static var lime_cairo_set_source_surface = System.load ("lime", "lime_cairo_set_source_surface", 4); + private static var lime_cairo_stroke = System.load ("lime", "lime_cairo_stroke", 1); + private static var lime_cairo_stroke_preserve = System.load ("lime", "lime_cairo_stroke_preserve", 1); + private static var lime_cairo_transform = System.load ("lime", "lime_cairo_transform", 2); private static var lime_cairo_version = System.load ("lime", "lime_cairo_version", 0); private static var lime_cairo_version_string = System.load ("lime", "lime_cairo_version_string", 0); #end diff --git a/lime/graphics/cairo/CairoContent.hx b/lime/graphics/cairo/CairoContent.hx new file mode 100644 index 000000000..5ee82d8ee --- /dev/null +++ b/lime/graphics/cairo/CairoContent.hx @@ -0,0 +1,10 @@ +package lime.graphics.cairo; + + +@:enum abstract CairoContent(Int) from Int to Int { + + public var COLOR = 0x1000; + public var ALPHA = 0x2000; + public var COLOR_ALPHA = 0x3000; + +} \ No newline at end of file diff --git a/lime/graphics/cairo/CairoExtend.hx b/lime/graphics/cairo/CairoExtend.hx new file mode 100644 index 000000000..80f580f13 --- /dev/null +++ b/lime/graphics/cairo/CairoExtend.hx @@ -0,0 +1,11 @@ +package lime.graphics.cairo; + + +@:enum abstract CairoExtend(Int) from Int to Int { + + public var NONE = 0; + public var REPEAT = 1; + public var REFLECT = 2; + public var PAD = 3; + +} \ No newline at end of file diff --git a/lime/graphics/cairo/CairoFilter.hx b/lime/graphics/cairo/CairoFilter.hx new file mode 100644 index 000000000..36df448fb --- /dev/null +++ b/lime/graphics/cairo/CairoFilter.hx @@ -0,0 +1,13 @@ +package lime.graphics.cairo; + + +@:enum abstract CairoFilter(Int) from Int to Int { + + public var FAST = 0; + public var GOOD = 1; + public var BEST = 2; + public var NEAREST = 3; + public var BILINEAR = 4; + public var GAUSSIAN = 5; + +} \ No newline at end of file diff --git a/lime/graphics/cairo/CairoLineCap.hx b/lime/graphics/cairo/CairoLineCap.hx new file mode 100644 index 000000000..4a326dc43 --- /dev/null +++ b/lime/graphics/cairo/CairoLineCap.hx @@ -0,0 +1,10 @@ +package lime.graphics.cairo; + + +@:enum abstract CairoLineCap(Int) from Int to Int { + + public var BUTT = 0; + public var ROUND = 1; + public var SQUARE = 2; + +} \ No newline at end of file diff --git a/lime/graphics/cairo/CairoLineJoin.hx b/lime/graphics/cairo/CairoLineJoin.hx new file mode 100644 index 000000000..51d43fc0a --- /dev/null +++ b/lime/graphics/cairo/CairoLineJoin.hx @@ -0,0 +1,10 @@ +package lime.graphics.cairo; + + +@:enum abstract CairoLineJoin(Int) from Int to Int { + + public var MITER = 0; + public var ROUND = 1; + public var BEVEL = 2; + +} \ No newline at end of file diff --git a/lime/graphics/cairo/CairoOperator.hx b/lime/graphics/cairo/CairoOperator.hx new file mode 100644 index 000000000..39fb69b9b --- /dev/null +++ b/lime/graphics/cairo/CairoOperator.hx @@ -0,0 +1,36 @@ +package lime.graphics.cairo; + + +@:enum abstract CairoOperator(Int) from Int to Int { + + public var CLEAR = 0; + public var SOURCE = 1; + public var OVER = 2; + public var IN = 3; + public var OUT = 4; + public var ATOP = 5; + public var DEST = 6; + public var DEST_OVER = 7; + public var DEST_IN = 8; + public var DEST_OUT = 9; + public var DEST_ATOP = 10; + public var XOR = 11; + public var ADD = 12; + public var SATURATE = 13; + public var MULTIPLY = 14; + public var SCREEN = 15; + public var OVERLAY = 16; + public var DARKEN = 17; + public var LIGHTEN = 18; + public var COLOR_DODGE = 19; + public var COLOR_BURN = 20; + public var HARD_LIGHT = 21; + public var SOFT_LIGHT = 22; + public var DIFFERENCE = 23; + public var EXCLUSION = 24; + public var HSL_HUE = 25; + public var HSL_SATURATION = 26; + public var HSL_COLOR = 27; + public var HSL_LUMINOSITY = 28; + +} \ No newline at end of file diff --git a/lime/graphics/cairo/CairoPattern.hx b/lime/graphics/cairo/CairoPattern.hx new file mode 100644 index 000000000..4bc130037 --- /dev/null +++ b/lime/graphics/cairo/CairoPattern.hx @@ -0,0 +1,132 @@ +package lime.graphics.cairo; + + +import lime.math.Matrix3; +import lime.system.System; + + +abstract CairoPattern(Dynamic) { + + + public var extend (get, set):CairoExtend; + public var filter (get, set):CairoFilter; + public var matrix (get, set):Matrix3; + + + public function new (handle) { + + this = handle; + + } + + + public static function createForSurface (surface:CairoSurface):CairoPattern { + + return lime_cairo_pattern_create_for_surface (surface); + + } + + + public function destroy ():Void { + + #if lime_cairo + lime_cairo_pattern_destroy (this); + #end + + } + + + + + // Get & Set Methods + + + + + public function get_extend ():CairoExtend { + + #if lime_cairo + return lime_cairo_pattern_get_extend (this); + #else + return 0; + #end + + } + + + public function set_extend (value:CairoExtend):CairoExtend { + + #if lime_cairo + lime_cairo_pattern_set_extend (this, value); + #end + + return value; + + } + + + public function get_filter ():CairoFilter { + + #if lime_cairo + return lime_cairo_pattern_get_filter (this); + #else + return 0; + #end + + } + + + public function set_filter (value:CairoFilter):CairoFilter { + + #if lime_cairo + lime_cairo_pattern_set_filter (this, value); + #end + + return value; + + } + + + public function get_matrix ():Matrix3 { + + #if lime_cairo + var m = lime_cairo_pattern_get_matrix (this); + return new Matrix3 (m.a, m.b, m.c, m.d, m.tx, m.ty); + #else + return null; + #end + + } + + + public function set_matrix (value:Matrix3):Matrix3 { + + #if lime_cairo + lime_cairo_pattern_set_matrix (this, value); + #end + + return value; + + } + + + + + // Native Methods + + + + + #if lime_cairo + private static var lime_cairo_pattern_create_for_surface = System.load ("lime", "lime_cairo_pattern_create_for_surface", 1); + private static var lime_cairo_pattern_destroy = System.load ("lime", "lime_cairo_pattern_destroy", 1); + private static var lime_cairo_pattern_get_extend = System.load ("lime", "lime_cairo_pattern_get_extend", 1); + private static var lime_cairo_pattern_get_filter = System.load ("lime", "lime_cairo_pattern_get_filter", 1); + private static var lime_cairo_pattern_get_matrix = System.load ("lime", "lime_cairo_pattern_get_matrix", 1); + private static var lime_cairo_pattern_set_extend = System.load ("lime", "lime_cairo_pattern_set_extend", 2); + private static var lime_cairo_pattern_set_filter = System.load ("lime", "lime_cairo_pattern_set_filter", 2); + private static var lime_cairo_pattern_set_matrix = System.load ("lime", "lime_cairo_pattern_set_matrix", 2); + #end + + +} \ No newline at end of file diff --git a/lime/graphics/cairo/CairoSurface.hx b/lime/graphics/cairo/CairoSurface.hx index 021ace13e..e822041f8 100644 --- a/lime/graphics/cairo/CairoSurface.hx +++ b/lime/graphics/cairo/CairoSurface.hx @@ -1,14 +1,55 @@ package lime.graphics.cairo; +import lime.system.System; + + abstract CairoSurface(Dynamic) { - public function new (handle) { + public function new (format:CairoFormat, width:Int, height:Int):CairoSurface { - this = handle; + #if lime_cairo + this = lime_cairo_image_surface_create (format, width, height); + #else + this = 0; + #end } + public static function createForData (data:Dynamic, format:CairoFormat, width:Int, height:Int, stride:Int):CairoSurface { + + #if lime_cairo + return lime_cairo_image_surface_create_for_data (data, format, width, height, stride); + #else + return 0; + #end + + } + + + public function destroy ():Void { + + #if lime_cairo + lime_cairo_surface_destroy (this); + #end + + } + + + + + // Native Methods + + + + + #if lime_cairo + private static var lime_cairo_image_surface_create = System.load ("lime", "lime_cairo_image_surface_create", 3); + private static var lime_cairo_image_surface_create_for_data = System.load ("lime", "lime_cairo_image_surface_create_for_data", 5); + private static var lime_cairo_surface_destroy = System.load ("lime", "lime_cairo_surface_destroy", 1); + #end + + } \ No newline at end of file diff --git a/project/Build.xml b/project/Build.xml index 9cf98b721..3ca33d05d 100644 --- a/project/Build.xml +++ b/project/Build.xml @@ -183,6 +183,7 @@ + diff --git a/project/include/math/Matrix3.h b/project/include/math/Matrix3.h new file mode 100644 index 000000000..ca54c5af6 --- /dev/null +++ b/project/include/math/Matrix3.h @@ -0,0 +1,36 @@ +#ifndef LIME_MATH_MATRIX_3_H +#define LIME_MATH_MATRIX_3_H + + +#include + + +namespace lime { + + + class Matrix3 { + + + public: + + Matrix3 (); + Matrix3 (double a, double b, double c, double d, double tx, double ty); + Matrix3 (value matrix3); + + value Value (); + + double a; + double b; + double c; + double d; + double tx; + double ty; + + + }; + + +} + + +#endif \ No newline at end of file diff --git a/project/include/math/Rectangle.h b/project/include/math/Rectangle.h index 68bee23a4..a6b94f9e2 100644 --- a/project/include/math/Rectangle.h +++ b/project/include/math/Rectangle.h @@ -14,6 +14,7 @@ namespace lime { public: Rectangle (); + Rectangle (double x, double y, double width, double height); Rectangle (value rect); double height; diff --git a/project/src/graphics/cairo/CairoBindings.cpp b/project/src/graphics/cairo/CairoBindings.cpp index 863d1e4cd..ab0bada82 100644 --- a/project/src/graphics/cairo/CairoBindings.cpp +++ b/project/src/graphics/cairo/CairoBindings.cpp @@ -1,10 +1,110 @@ #include +#include #include namespace lime { + value lime_cairo_clip (value handle) { + + cairo_clip ((cairo_t*)(intptr_t)val_float (handle)); + return alloc_null (); + + } + + + value lime_cairo_close_path (value handle) { + + cairo_close_path ((cairo_t*)(intptr_t)val_float (handle)); + return alloc_null (); + + } + + + value lime_cairo_create (value surface) { + + return alloc_float ((intptr_t)cairo_create ((cairo_surface_t*)(intptr_t)val_float (surface))); + + } + + + value lime_cairo_destroy (value handle) { + + cairo_destroy ((cairo_t*)(intptr_t)val_float (handle)); + return alloc_null (); + + } + + + value lime_cairo_fill (value handle) { + + cairo_fill ((cairo_t*)(intptr_t)val_float (handle)); + return alloc_null (); + + } + + + value lime_cairo_fill_preserve (value handle) { + + cairo_fill_preserve ((cairo_t*)(intptr_t)val_float (handle)); + return alloc_null (); + + } + + + value lime_cairo_get_line_cap (value handle) { + + return alloc_int (cairo_get_line_cap ((cairo_t*)(intptr_t)val_float (handle))); + + } + + + value lime_cairo_get_line_join (value handle) { + + return alloc_int (cairo_get_line_join ((cairo_t*)(intptr_t)val_float (handle))); + + } + + + value lime_cairo_get_line_width (value handle) { + + return alloc_float (cairo_get_line_width ((cairo_t*)(intptr_t)val_float (handle))); + + } + + + value lime_cairo_get_matrix (value handle) { + + cairo_matrix_t cm; + cairo_get_matrix ((cairo_t*)(intptr_t)val_float (handle), &cm); + Matrix3 mat3 = Matrix3 (cm.xx, cm.yx, cm.xy, cm.yy, cm.x0, cm.y0); + return mat3.Value (); + + } + + + value lime_cairo_get_miter_limit (value handle) { + + return alloc_float (cairo_get_miter_limit ((cairo_t*)(intptr_t)val_float (handle))); + + } + + + value lime_cairo_get_operator (value handle) { + + return alloc_int (cairo_get_operator ((cairo_t*)(intptr_t)val_float (handle))); + + } + + + value lime_cairo_get_source (value handle) { + + return alloc_float ((intptr_t)cairo_get_source ((cairo_t*)(intptr_t)val_float (handle))); + + } + + value lime_cairo_image_surface_create (value format, value width, value height) { return alloc_float ((intptr_t)cairo_image_surface_create ((cairo_format_t)val_int (format), val_int (width), val_int (height))); @@ -12,6 +112,306 @@ namespace lime { } + value lime_cairo_image_surface_create_for_data (value data, value format, value width, value height, value stride) { + + return alloc_float ((intptr_t)cairo_image_surface_create_for_data ((unsigned char*)(intptr_t)val_float (data), (cairo_format_t)val_int (format), val_int (width), val_int (height), val_int (stride))); + + } + + + value lime_cairo_line_to (value handle, value x, value y) { + + cairo_line_to ((cairo_t*)(intptr_t)val_float (handle), val_float (x), val_float (y)); + return alloc_null (); + + } + + + value lime_cairo_mask (value handle, value pattern) { + + cairo_mask ((cairo_t*)(intptr_t)val_float (handle), (cairo_pattern_t*)(intptr_t)val_float (pattern)); + return alloc_null (); + + } + + + value lime_cairo_move_to (value handle, value x, value y) { + + cairo_move_to ((cairo_t*)(intptr_t)val_float (handle), val_float (x), val_float (y)); + return alloc_null (); + + } + + + value lime_cairo_new_path (value handle) { + + cairo_new_path ((cairo_t*)(intptr_t)val_float (handle)); + return alloc_null (); + + } + + + value lime_cairo_paint (value handle) { + + cairo_paint ((cairo_t*)(intptr_t)val_float (handle)); + return alloc_null (); + + } + + + value lime_cairo_paint_with_alpha (value handle, value alpha) { + + cairo_paint_with_alpha ((cairo_t*)(intptr_t)val_float (handle), val_float (alpha)); + return alloc_null (); + + } + + + value lime_cairo_pop_group (value handle) { + + return alloc_float ((intptr_t)cairo_pop_group ((cairo_t*)(intptr_t)val_float (handle))); + + } + + + value lime_cairo_pop_group_to_source (value handle) { + + cairo_pop_group_to_source ((cairo_t*)(intptr_t)val_float (handle)); + return alloc_null (); + + } + + + value lime_cairo_push_group (value handle) { + + cairo_push_group ((cairo_t*)(intptr_t)val_float (handle)); + return alloc_null (); + + } + + + value lime_cairo_push_group_with_content (value handle, value content) { + + cairo_push_group_with_content ((cairo_t*)(intptr_t)val_float (handle), (cairo_content_t)val_int (content)); + return alloc_null (); + + } + + + value lime_cairo_rectangle (value handle, value x, value y, value width, value height) { + + cairo_rectangle ((cairo_t*)(intptr_t)val_float (handle), val_float (x), val_float (y), val_float (width), val_float (height)); + return alloc_null (); + + } + + + value lime_cairo_reset_clip (value handle) { + + cairo_reset_clip ((cairo_t*)(intptr_t)val_float (handle)); + return alloc_null (); + + } + + + value lime_cairo_restore (value handle) { + + cairo_restore ((cairo_t*)(intptr_t)val_float (handle)); + return alloc_null (); + + } + + + value lime_cairo_save (value handle) { + + cairo_save ((cairo_t*)(intptr_t)val_float (handle)); + return alloc_null (); + + } + + + value lime_cairo_set_line_cap (value handle, value cap) { + + cairo_set_line_cap ((cairo_t*)(intptr_t)val_float (handle), (cairo_line_cap_t)val_int (cap)); + return alloc_null (); + + } + + + value lime_cairo_set_line_join (value handle, value join) { + + cairo_set_line_join ((cairo_t*)(intptr_t)val_float (handle), (cairo_line_join_t)val_int (join)); + return alloc_null (); + + } + + + value lime_cairo_set_line_width (value handle, value width) { + + cairo_set_line_width ((cairo_t*)(intptr_t)val_float (handle), val_float (width)); + return alloc_null (); + + } + + + value lime_cairo_set_matrix (value handle, value matrix) { + + Matrix3 mat3 = Matrix3 (matrix); + + cairo_matrix_t cm; + cairo_matrix_init (&cm, mat3.a, mat3.b, mat3.c, mat3.d, mat3.tx, mat3.ty); + + cairo_set_matrix ((cairo_t*)(intptr_t)val_float (handle), &cm); + return alloc_null (); + + } + + + value lime_cairo_set_miter_limit (value handle, value miterLimit) { + + cairo_set_miter_limit ((cairo_t*)(intptr_t)val_float (handle), val_float (miterLimit)); + return alloc_null (); + + } + + + value lime_cairo_set_operator (value handle, value op) { + + cairo_set_operator ((cairo_t*)(intptr_t)val_float (handle), (cairo_operator_t)val_int (op)); + return alloc_null (); + + } + + + value lime_cairo_set_source (value handle, value pattern) { + + cairo_set_source ((cairo_t*)(intptr_t)val_float (handle), (cairo_pattern_t*)(intptr_t)val_float (pattern)); + return alloc_null (); + + } + + + value lime_cairo_set_source_rgba (value handle, value r, value g, value b, value a) { + + cairo_set_source_rgba ((cairo_t*)(intptr_t)val_float (handle), val_float (r), val_float (g), val_float (b), val_float (a)); + return alloc_null (); + + } + + + value lime_cairo_set_source_surface (value handle, value surface, value x, value y) { + + cairo_set_source_surface ((cairo_t*)(intptr_t)val_float (handle), (cairo_surface_t*)(intptr_t)val_float (surface), val_float (x), val_float (y)); + return alloc_null (); + + } + + + value lime_cairo_stroke (value handle) { + + cairo_stroke ((cairo_t*)(intptr_t)val_float (handle)); + return alloc_null (); + + } + + + value lime_cairo_stroke_preserve (value handle) { + + cairo_stroke_preserve ((cairo_t*)(intptr_t)val_float (handle)); + return alloc_null (); + + } + + + value lime_cairo_transform (value handle, value matrix) { + + Matrix3 mat3 = Matrix3 (matrix); + + cairo_matrix_t cm; + cairo_matrix_init (&cm, mat3.a, mat3.b, mat3.c, mat3.d, mat3.tx, mat3.ty); + + cairo_transform ((cairo_t*)(intptr_t)val_float (handle), &cm); + return alloc_null (); + + } + + + value lime_cairo_pattern_create_for_surface (value surface) { + + return alloc_float ((intptr_t)cairo_pattern_create_for_surface ((cairo_surface_t*)(intptr_t)val_float (surface))); + + } + + + value lime_cairo_pattern_destroy (value handle) { + + cairo_pattern_destroy ((cairo_pattern_t*)(intptr_t)val_float (handle)); + return alloc_null (); + + } + + + value lime_cairo_pattern_get_extend (value handle) { + + return alloc_int (cairo_pattern_get_extend ((cairo_pattern_t*)(intptr_t)val_float (handle))); + + } + + + value lime_cairo_pattern_set_extend (value handle, value extend) { + + cairo_pattern_set_extend ((cairo_pattern_t*)(intptr_t)val_float (handle), (cairo_extend_t)val_int (extend)); + return alloc_null (); + + } + + + value lime_cairo_pattern_get_filter (value handle) { + + return alloc_int (cairo_pattern_get_filter ((cairo_pattern_t*)(intptr_t)val_float (handle))); + + } + + + value lime_cairo_pattern_set_filter (value handle, value filter) { + + cairo_pattern_set_filter ((cairo_pattern_t*)(intptr_t)val_float (handle), (cairo_filter_t)val_int (filter)); + return alloc_null (); + + } + + + value lime_cairo_pattern_get_matrix (value handle) { + + cairo_matrix_t cm; + cairo_pattern_get_matrix ((cairo_pattern_t*)(intptr_t)val_float (handle), &cm); + Matrix3 mat3 = Matrix3 (cm.xx, cm.yx, cm.xy, cm.yy, cm.x0, cm.y0); + return mat3.Value (); + + } + + + value lime_cairo_pattern_set_matrix (value handle, value matrix) { + + Matrix3 mat3 = Matrix3 (matrix); + + cairo_matrix_t cm; + cairo_matrix_init (&cm, mat3.a, mat3.b, mat3.c, mat3.d, mat3.tx, mat3.ty); + + cairo_pattern_set_matrix ((cairo_pattern_t*)(intptr_t)val_float (handle), &cm); + return alloc_null (); + + } + + + value lime_cairo_surface_destroy (value handle) { + + cairo_surface_destroy ((cairo_surface_t*)(intptr_t)val_float (handle)); + return alloc_null (); + + } + + value lime_cairo_version () { return alloc_int (cairo_version ()); @@ -26,7 +426,56 @@ namespace lime { } + DEFINE_PRIM (lime_cairo_clip, 1); + DEFINE_PRIM (lime_cairo_close_path, 1); + DEFINE_PRIM (lime_cairo_create, 1); + DEFINE_PRIM (lime_cairo_destroy, 1); + DEFINE_PRIM (lime_cairo_fill, 1); + DEFINE_PRIM (lime_cairo_fill_preserve, 1); + DEFINE_PRIM (lime_cairo_get_line_cap, 1); + DEFINE_PRIM (lime_cairo_get_line_join, 1); + DEFINE_PRIM (lime_cairo_get_line_width, 1); + DEFINE_PRIM (lime_cairo_get_matrix, 1); + DEFINE_PRIM (lime_cairo_get_miter_limit, 1); + DEFINE_PRIM (lime_cairo_get_operator, 1); + DEFINE_PRIM (lime_cairo_get_source, 1); DEFINE_PRIM (lime_cairo_image_surface_create, 3); + DEFINE_PRIM (lime_cairo_image_surface_create_for_data, 5); + DEFINE_PRIM (lime_cairo_line_to, 3); + DEFINE_PRIM (lime_cairo_mask, 2); + DEFINE_PRIM (lime_cairo_move_to, 3); + DEFINE_PRIM (lime_cairo_new_path, 1); + DEFINE_PRIM (lime_cairo_paint, 1); + DEFINE_PRIM (lime_cairo_paint_with_alpha, 2); + DEFINE_PRIM (lime_cairo_pop_group, 1); + DEFINE_PRIM (lime_cairo_pop_group_to_source, 1); + DEFINE_PRIM (lime_cairo_push_group, 1); + DEFINE_PRIM (lime_cairo_push_group_with_content, 2); + DEFINE_PRIM (lime_cairo_rectangle, 5); + DEFINE_PRIM (lime_cairo_reset_clip, 1); + DEFINE_PRIM (lime_cairo_restore, 1); + DEFINE_PRIM (lime_cairo_save, 1); + DEFINE_PRIM (lime_cairo_set_line_cap, 2); + DEFINE_PRIM (lime_cairo_set_line_join, 2); + DEFINE_PRIM (lime_cairo_set_line_width, 2); + DEFINE_PRIM (lime_cairo_set_matrix, 2); + DEFINE_PRIM (lime_cairo_set_miter_limit, 2); + DEFINE_PRIM (lime_cairo_set_operator, 2); + DEFINE_PRIM (lime_cairo_set_source, 2); + DEFINE_PRIM (lime_cairo_set_source_rgba, 5); + DEFINE_PRIM (lime_cairo_set_source_surface, 4); + DEFINE_PRIM (lime_cairo_stroke, 1); + DEFINE_PRIM (lime_cairo_stroke_preserve, 1); + DEFINE_PRIM (lime_cairo_transform, 2); + DEFINE_PRIM (lime_cairo_pattern_create_for_surface, 1); + DEFINE_PRIM (lime_cairo_pattern_destroy, 1); + DEFINE_PRIM (lime_cairo_pattern_get_extend, 1); + DEFINE_PRIM (lime_cairo_pattern_get_filter, 1); + DEFINE_PRIM (lime_cairo_pattern_get_matrix, 1); + DEFINE_PRIM (lime_cairo_pattern_set_extend, 2); + DEFINE_PRIM (lime_cairo_pattern_set_filter, 2); + DEFINE_PRIM (lime_cairo_pattern_set_matrix, 2); + DEFINE_PRIM (lime_cairo_surface_destroy, 1); DEFINE_PRIM (lime_cairo_version, 0); DEFINE_PRIM (lime_cairo_version_string, 0); diff --git a/project/src/math/Matrix3.cpp b/project/src/math/Matrix3.cpp new file mode 100644 index 000000000..6ade88314 --- /dev/null +++ b/project/src/math/Matrix3.cpp @@ -0,0 +1,78 @@ +#include + + +namespace lime { + + + static int id_a; + static int id_b; + static int id_c; + static int id_d; + static int id_tx; + static int id_ty; + static bool init = false; + + + Matrix3::Matrix3 () { + + a = 1; + b = 0; + c = 0; + d = 1; + tx = 0; + ty = 0; + + } + + + Matrix3::Matrix3 (double a, double b, double c, double d, double tx, double ty) { + + this->a = a; + this->b = b; + this->c = c; + this->d = d; + this->tx = tx; + this->ty = ty; + + } + + + Matrix3::Matrix3 (value mat3) { + + if (!init) { + + id_a = val_id ("a"); + id_b = val_id ("b"); + id_c = val_id ("c"); + id_d = val_id ("d"); + id_tx = val_id ("tx"); + id_ty = val_id ("ty"); + init = true; + + } + + a = val_number (val_field (mat3, id_a)); + b = val_number (val_field (mat3, id_b)); + c = val_number (val_field (mat3, id_c)); + d = val_number (val_field (mat3, id_d)); + tx = val_number (val_field (mat3, id_tx)); + ty = val_number (val_field (mat3, id_ty)); + + } + + + value Matrix3::Value () { + + value result = alloc_empty_object (); + alloc_field (result, id_a, alloc_float (a)); + alloc_field (result, id_b, alloc_float (b)); + alloc_field (result, id_c, alloc_float (c)); + alloc_field (result, id_d, alloc_float (d)); + alloc_field (result, id_tx, alloc_float (tx)); + alloc_field (result, id_ty, alloc_float (ty)); + return result; + + } + + +} \ No newline at end of file diff --git a/project/src/math/Rectangle.cpp b/project/src/math/Rectangle.cpp index 7c9958d57..dcdc0c5bf 100644 --- a/project/src/math/Rectangle.cpp +++ b/project/src/math/Rectangle.cpp @@ -21,6 +21,16 @@ namespace lime { } + Rectangle::Rectangle (double x, double y, double width, double height) { + + this->height = height; + this->width = width; + this->x = x; + this->y = y; + + } + + Rectangle::Rectangle (value rect) { if (!init) {