Merge pull request #494 from LLK/revert-467-rect-init-matrix

Revert "Initialialize AABB Rectangle "

src/BitmapSkin.js

@@ -62,11 +62,10 @@ class BitmapSkin extends Skin {
     /**
      * Get the bounds of the drawable for determining its fenced position.
      * @param {Array<number>} drawable - The Drawable instance this skin is using.
-     * @param {?Rectangle} result - Optional destination for bounds calculation.
      * @return {!Rectangle} The drawable's bounds. For compatibility with Scratch 2, we always use getAABB for bitmaps.
      */
-    getFenceBounds (drawable, result) {
-        return drawable.getAABB(result);
+    getFenceBounds (drawable) {
+        return drawable.getAABB();
     }
 
     /**

src/Drawable.js

@@ -451,10 +451,9 @@ class Drawable {
      * This function applies the transform matrix to the known convex hull,
      * and then finds the minimum box along the axes.
      * Before calling this, ensure the renderer has updated convex hull points.
-     * @param {?Rectangle} result optional destination for bounds calculation
      * @return {!Rectangle} Bounds for a tight box around the Drawable.
      */
-    getBounds (result) {
+    getBounds () {
         if (this.needsConvexHullPoints()) {
             throw new Error('Needs updated convex hull points before bounds calculation.');
         }
@@ -463,19 +462,18 @@ class Drawable {
         }
         const transformedHullPoints = this._getTransformedHullPoints();
         // Search through transformed points to generate box on axes.
-        result = result || new Rectangle();
-        result.initFromPointsAABB(transformedHullPoints);
-        return result;
+        const bounds = new Rectangle();
+        bounds.initFromPointsAABB(transformedHullPoints);
+        return bounds;
     }
 
     /**
      * Get the precise bounds for the upper 8px slice of the Drawable.
      * Used for calculating where to position a text bubble.
      * Before calling this, ensure the renderer has updated convex hull points.
-     * @param {?Rectangle} result optional destination for bounds calculation
      * @return {!Rectangle} Bounds for a tight box around a slice of the Drawable.
      */
-    getBoundsForBubble (result) {
+    getBoundsForBubble () {
         if (this.needsConvexHullPoints()) {
             throw new Error('Needs updated convex hull points before bubble bounds calculation.');
         }
@@ -487,9 +485,9 @@ class Drawable {
         const maxY = Math.max.apply(null, transformedHullPoints.map(p => p[1]));
         const filteredHullPoints = transformedHullPoints.filter(p => p[1] > maxY - slice);
         // Search through filtered points to generate box on axes.
-        result = result || new Rectangle();
-        result.initFromPointsAABB(filteredHullPoints);
-        return result;
+        const bounds = new Rectangle();
+        bounds.initFromPointsAABB(filteredHullPoints);
+        return bounds;
     }
 
     /**
@@ -499,32 +497,35 @@ class Drawable {
      * which is tightly snapped to account for a Drawable's transparent regions.
      * `getAABB` returns a much less accurate bounding box, but will be much
      * faster to calculate so may be desired for quick checks/optimizations.
-     * @param {?Rectangle} result optional destination for bounds calculation
      * @return {!Rectangle} Rough axis-aligned bounding box for Drawable.
      */
-    getAABB (result) {
+    getAABB () {
         if (this._transformDirty) {
             this._calculateTransform();
         }
         const tm = this._uniforms.u_modelMatrix;
-        result = result || new Rectangle();
-        result.initFromModelMatrix(tm);
-        return result;
+        const bounds = new Rectangle();
+        bounds.initFromPointsAABB([
+            twgl.m4.transformPoint(tm, [-0.5, -0.5, 0]),
+            twgl.m4.transformPoint(tm, [0.5, -0.5, 0]),
+            twgl.m4.transformPoint(tm, [-0.5, 0.5, 0]),
+            twgl.m4.transformPoint(tm, [0.5, 0.5, 0])
+        ]);
+        return bounds;
     }
 
     /**
      * Return the best Drawable bounds possible without performing graphics queries.
      * I.e., returns the tight bounding box when the convex hull points are already
      * known, but otherwise return the rough AABB of the Drawable.
-     * @param {?Rectangle} result optional destination for bounds calculation
      * @return {!Rectangle} Bounds for the Drawable.
      */
-    getFastBounds (result) {
+    getFastBounds () {
         this.updateMatrix();
         if (!this.needsConvexHullPoints()) {
-            return this.getBounds(result);
+            return this.getBounds();
         }
-        return this.getAABB(result);
+        return this.getAABB();
     }
 
     /**

src/Rectangle.js

@@ -54,31 +54,6 @@ class Rectangle {
         }
     }
 
-    /**
-     * Initialize a Rectangle to a 1 unit square centered at 0 x 0 transformed
-     * by a model matrix.
-     * @param {Array.<number>} m A 4x4 matrix to transform the rectangle by.
-     * @tutorial Rectangle-AABB-Matrix
-     */
-    initFromModelMatrix (m) {
-        // In 2D space, we will soon use the 2x2 "top left" scale and rotation
-        // submatrix, while we store and the 1x2 "top right" that position
-        // vector.
-        const m30 = m[(3 * 4) + 0];
-        const m31 = m[(3 * 4) + 1];
-
-        // "Transform" a (0.5, 0.5) vector by the scale and rotation matrix but
-        // sum the absolute of each component instead of use the signed values.
-        const x = Math.abs(0.5 * m[(0 * 4) + 0]) + Math.abs(0.5 * m[(1 * 4) + 0]);
-        const y = Math.abs(0.5 * m[(0 * 4) + 1]) + Math.abs(0.5 * m[(1 * 4) + 1]);
-
-        // And adding them to the position components initializes our Rectangle.
-        this.left = -x + m30;
-        this.right = x + m30;
-        this.top = y + m31;
-        this.bottom = -y + m31;
-    }
-
     /**
      * Determine if this Rectangle intersects some other.
      * Note that this is a comparison assuming the Rectangle was

src/RenderWebGL.js

@@ -16,7 +16,6 @@ const log = require('./util/log');
 
 const __isTouchingDrawablesPoint = twgl.v3.create();
 const __candidatesBounds = new Rectangle();
-const __fenceBounds = new Rectangle();
 const __touchingColor = new Uint8ClampedArray(4);
 const __blendColor = new Uint8ClampedArray(4);
 
@@ -1358,7 +1357,7 @@ class RenderWebGL extends EventEmitter {
 
         const dx = x - drawable._position[0];
         const dy = y - drawable._position[1];
-        const aabb = drawable._skin.getFenceBounds(drawable, __fenceBounds);
+        const aabb = drawable._skin.getFenceBounds(drawable);
         const inset = Math.floor(Math.min(aabb.width, aabb.height) / 2);
 
         const sx = this._xRight - Math.min(FENCE_WIDTH, inset);
@@ -1628,14 +1627,14 @@ class RenderWebGL extends EventEmitter {
             }
 
             twgl.setUniforms(currentShader, uniforms);
-
+            
             /* adjust blend function for this skin */
             if (drawable.skin.hasPremultipliedAlpha){
                 gl.blendFuncSeparate(gl.ONE, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
             } else {
                 gl.blendFuncSeparate(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
             }
-
+            
             twgl.drawBufferInfo(gl, this._bufferInfo, gl.TRIANGLES);
         }
 

src/Skin.js

@@ -146,11 +146,10 @@ class Skin extends EventEmitter {
     /**
      * Get the bounds of the drawable for determining its fenced position.
      * @param {Array<number>} drawable - The Drawable instance this skin is using.
-     * @param {?Rectangle} result - Optional destination for bounds calculation.
      * @return {!Rectangle} The drawable's bounds.
      */
-    getFenceBounds (drawable, result) {
-        return drawable.getFastBounds(result);
+    getFenceBounds (drawable) {
+        return drawable.getFastBounds();
     }
 
     /**