1 goog.provide('lime.Polygon');
  2 goog.provide('lime.Renderer.CANVAS.POLYGON');
  3 
  4 
  5 goog.require('goog.array');
  6 goog.require('goog.math.Coordinate');
  7 goog.require('lime.Renderer.CANVAS.SPRITE');
  8 goog.require('lime.Sprite');
  9 
 10 /**
 11  * Polygon shaped textured object
 12  * @param {Array.<goog.math.Coodinate>} points Polygon points.
 13  * @constructor
 14  * @extends lime.Sprite
 15  */
 16 lime.Polygon = function(points) {
 17     lime.Sprite.call(this);
 18 
 19     this.setPoints.apply(this, arguments);
 20 };
 21 goog.inherits(lime.Polygon, lime.Sprite);
 22 
 23 /**
 24  * Common name for polygon objects
 25  * @type {string}
 26  */
 27 lime.Polygon.prototype.id = 'polygon';
 28 
 29 /** @inheritDoc */
 30 lime.Polygon.prototype.supportedRenderers = [
 31     lime.Renderer.CANVAS.SPRITE.makeSubRenderer(lime.Renderer.CANVAS.POLYGON)
 32 ];
 33 
 34 /**
 35  * Returns array of points that define the polygon
 36  * @return {Array.<goog.math.Coordinate>} Array of polygon points.
 37  */
 38 lime.Polygon.prototype.getPoints = function() {
 39     return this.points_;
 40 };
 41 
 42 /**
 43  * Sets points that define the polygon. Also accepts floats.
 44  * @param {Array.<goog.math.Coodinate>} points Polygon points.
 45  * @return {lime.Polygon} object itself.
 46  */
 47 lime.Polygon.prototype.setPoints = function(points) {
 48     this.points_ = [];
 49     this.addPoints.apply(this, arguments);
 50     return this;
 51 };
 52 
 53 /**
 54  * Adds points to current polygon points. Also accepts floats.
 55  * @param {Array.<goog.math.Coodinate>} points Polygon points.
 56  * @return {lime.Polygon} object itself.
 57  */
 58 lime.Polygon.prototype.addPoints = function(points) {
 59     var points = goog.array.toArray(arguments);
 60     if (!points.length) return;
 61 
 62     if (points[0] instanceof goog.math.Coordinate) {
 63         goog.array.forEach(points, function(p) {
 64            this.addPoint(p);
 65         },this);
 66     }
 67     else {
 68         for (var i = 1; i < points.length; i += 2) {
 69             this.addPoint(new goog.math.Coordinate(points[i - 1], points[i]));
 70         }
 71     }
 72     return this;
 73 };
 74 
 75 /**
 76  * Adds a point to current polygon points.
 77  * @param {goog.math.Coordinate} coord Point to add.
 78  * @return {lime.Polygon} object itself.
 79  */
 80 lime.Polygon.prototype.addPoint = function(coord) {
 81     if (!this.points_.length) {
 82         this.minX = this.maxX = coord.x;
 83         this.minY = this.maxY = coord.y;
 84     }
 85     else {
 86         this.minX = Math.min(coord.x, this.minX);
 87         this.minY = Math.min(coord.y, this.minY);
 88         this.maxX = Math.max(coord.x, this.maxX);
 89         this.maxY = Math.max(coord.y, this.maxY);
 90     }
 91 
 92     this.points_.push(coord);
 93     return this;
 94 };
 95 
 96 /** @inheritDoc */
 97 lime.Polygon.prototype.getSize = function() {
 98     return new goog.math.Size(this.maxX - this.minX, this.maxY - this.minY);
 99 };
100 
101 /** @inheritDoc */
102 lime.Polygon.prototype.getAnchorPoint = function() {
103     var size = this.getSize();
104     return new goog.math.Vec2(
105         -this.minX / size.width, -this.minY / size.height);
106 };
107 
108 /**
109  * @inheritDoc
110  */
111 lime.Polygon.prototype.hitTest = function(e) {
112     var p = this.getPoints(),
113         plen = p.length,
114         coord = this.screenToLocal(e.screenPosition),
115         inPoly = false;
116 
117     if (plen > 2) {
118         var i, j, c = 0;
119 
120         for (i = 0, j = plen - 1; i < plen; j = i++) {
121             if (((p[i].y > coord.y) != (p[j].y > coord.y)) &&
122                 (coord.x < (p[j].x - p[i].x) * (coord.y - p[i].y) /
123                     (p[j].y - p[i].y) + p[i].x)) {
124                     inPoly = !inPoly;
125                 }
126         }
127     }
128 
129     return inPoly;
130 };
131 
132 /**
133  * @inheritDoc
134  * @this {lime.Polygon}
135  */
136 lime.Renderer.CANVAS.POLYGON.draw = function(context) {
137 
138 
139     var size = this.getSize(), fill = this.fill_;
140 
141     var pt = this.getPoints();
142     
143 
144     if (pt.length > 2) {
145 
146        context.save();
147        context.beginPath();
148        context.moveTo(pt[0].x, pt[0].y);
149 
150        for (var i = 1; i < pt.length; i++) {
151            context.lineTo(pt[i].x, pt[i].y);
152 
153        }
154 
155        context.closePath();
156        if(fill)
157        context.fillStyle = fill.str;
158 
159 
160        context.clip();
161 
162 
163 
164     lime.Renderer.CANVAS.SPRITE.draw.call(this, context);
165     
166     if(this.stroke_){
167         context.lineWidth*=2;
168         context.stroke();
169     }
170     
171     context.restore();
172     }
173 };
174