3 files changed, 142 insertions, 18 deletions

diff --git a/js/lib/geom/circle.js b/js/lib/geom/circle.js
index 218dcfa6..0f1f49a9 100755
--- a/js/lib/geom/circle.js
+++ b/js/lib/geom/circle.js
@@ -4,9 +4,12 @@ No rights, expressed or implied, whatsoever to this software are provided by Mot
 (c) Copyright 2011 Motorola Mobility, Inc.  All Rights Reserved.
 </copyright> */
 
-var GeomObj =           require("js/lib/geom/geom-obj").GeomObj;
-var ShapePrimitive =    require("js/lib/geom/shape-primitive").ShapePrimitive;
-var MaterialsModel = require("js/models/materials-model").MaterialsModel;
+var GeomObj                     = require("js/lib/geom/geom-obj").GeomObj;
+var ShapePrimitive      = require("js/lib/geom/shape-primitive").ShapePrimitive;
+var MaterialsModel      = require("js/models/materials-model").MaterialsModel;
+var drawUtils           = require("js/helper-classes/3D/draw-utils").DrawUtils;
+var vecUtils            = require("js/helper-classes/3D/vec-utils").VecUtils;
+
 ///////////////////////////////////////////////////////////////////////
 // Class GLCircle
 //      GL representation of a circle.
@@ -46,6 +49,10 @@ var Circle = function GLCircle() {
                         this._fillColor = fillColor;
 
                         this._strokeStyle = strokeStyle;
+
+                        this._matrix = Matrix.I(4);
+                        //this._matrix[12] = xOffset;
+                        //this._matrix[13] = yOffset;
                 }
 
                 this.m_world = world;
@@ -187,7 +194,7 @@ var Circle = function GLCircle() {
                 // get the normalized device coordinates (NDC) for
                 // all position and dimensions.
                 var     vpw = world.getViewportWidth(),  vph = world.getViewportHeight();
-                var     xNDC = 2*this._xOffset/vpw,  yNDC = 2*this._yOffset/vph,
+                var     xNDC = 2*this._xOffset/vpw,  yNDC = -2*this._yOffset/vph,
                         xRadNDC = this._width/vpw,  yRadNDC = this._height/vph,
                         xStrokeNDC = 2*this._strokeWidth/vpw,  yStrokeNDC = 2*this._strokeWidth/vph,
                         xInnRadNDC = this._innerRadius*xRadNDC,  yInnRadNDC = this._innerRadius*yRadNDC;
@@ -706,6 +713,49 @@ var Circle = function GLCircle() {
                 return (MathUtils.fpCmp(distToPt,distToBoundary) <= 0);
     };
 
+    this.getNearPoint = function( pt, dir )
+        {
+        var world = this.getWorld();
+        if (!world)  throw( "null world in getNearPoint" );
+                
+                // the input point and direction are in GL space
+                // project to the z == 0 plane
+                var mat = this.getMatrix();
+                var plane = [0,0,1,0];
+                plane = MathUtils.transformPlane( plane, mat );
+                var projPt = MathUtils.vecIntersectPlane ( pt, dir, plane );
+
+                // get the center of the circle in GL space
+                var ctr = this.getGLCenter();
+
+                // transform the projected point to the plane of the circle
+                var planePt = MathUtils.transformPoint( projPt, mat );
+
+                // get a matrix mapping the circle to a 2D coordinate system
+                var normal = [ mat[8], mat[9], mat[10] ];
+                var planeMat = drawUtils.getPlaneToWorldMatrix(normal, ctr);
+                var planeMatInv = glmat4.inverse( planeMat, [] );
+                var planePt2D = MathUtils.transformPoint( planePt, planeMatInv );
+
+                // get 2 points on the axes of the oval
+                var wPt = this.preViewToGL( [this._xOffset + 0.5*this.getWidth(),   this._yOffset,  0] ),
+                        hPt = this.preViewToGL( [this._xOffset,  this._yOffset + 0.5*this.getHeight(),  0] );
+                var w = vecUtils.vecDist( 2, wPt, ctr ),
+                        h = vecUtils.vecDist( 2, hPt, ctr );
+                var aspect = w/h;
+
+                // get the angle of the projected point relative to the circle
+                var angle = Math.atan2( planePt2D[1], planePt2D[0]/aspect );
+                var degrees = angle*180.0/Math.PI;
+
+                // get the corresponding point on the object
+                var pt = [ Math.cos(angle)*w,  Math.sin(angle)*h,  0 ];
+                var glPt = MathUtils.transformPoint( pt, planeMat );
+
+                return glPt;
+        }
+
+        /*
     this.getNearPoint = function( pt, dir ) {
         var world = this.getWorld();
         if (!world)  throw( "null world in getNearPoint" );
@@ -725,7 +775,7 @@ var Circle = function GLCircle() {
                 // get the normalized device coordinates (NDC) for
                 // the position and radii.
                 var     vpw = world.getViewportWidth(),  vph = world.getViewportHeight();
-                var     xNDC = 2*this._xOffset/vpw,  yNDC = 2*this._yOffset/vph,
+                var     xNDC = 2*this._xOffset/vpw,  yNDC = -2*this._yOffset/vph,
                         xRadNDC = this._width/vpw,  yRadNDC = this._height/vph;
                 var projMat = world.makePerspectiveMatrix();
                 var z = -world.getViewDistance();
@@ -755,6 +805,7 @@ var Circle = function GLCircle() {
 
                 return objPt;
     };
+        */
 
          this.recalcTexMapCoords = function( vrts, uvs ) {
                 var n = vrts.length/3;
diff --git a/js/lib/geom/geom-obj.js b/js/lib/geom/geom-obj.js
index f2991bdb..7cb9b80f 100755
--- a/js/lib/geom/geom-obj.js
+++ b/js/lib/geom/geom-obj.js
@@ -375,6 +375,65 @@ var GeomObj = function GLGeomObj() {
         }
     };
 
+
+        this.getGLCenter = function()
+        {
+                // get the normalized device coordinates (NDC) for
+                // all position and dimensions.
+                var world = this.getWorld();
+                var     vpw = world.getViewportWidth(),  vph = world.getViewportHeight();
+                var     xNDC = 2*this._xOffset/vpw,  yNDC = -2*this._yOffset/vph;
+
+                var aspect = world.getAspect();
+                var zn = world.getZNear(),  zf = world.getZFar();
+                var     t = zn * Math.tan(world.getFOV() * Math.PI / 360.0),
+                        b = -t,
+                        r = aspect*t,
+                        l = -r;
+
+                // calculate the object coordinates from their NDC coordinates
+                var z = -world.getViewDistance();
+
+                // unproject to get the position of the origin in GL
+                var x = -z*(r-l)/(2.0*zn)*xNDC,
+                        y = -z*(t-b)/(2.0*zn)*yNDC;
+                z = 0.0;
+
+                // transform by the object's transformation matrix
+                var ctr = MathUtils.transformPoint( [x, y, z], this.getMatrix() );
+
+                return ctr;
+        };
+
+        this.preViewToGL = function( preViewPt )
+        {
+                // get the normalized device coordinates (NDC) for
+                // all position and dimensions.
+                var world = this.getWorld();
+                var     vpw = world.getViewportWidth(),  vph = world.getViewportHeight();
+                var     xNDC = 2*preViewPt[0]/vpw,  yNDC = -2*preViewPt[1]/vph;
+
+                var aspect = world.getAspect();
+                var zn = world.getZNear(),  zf = world.getZFar();
+                var     t = zn * Math.tan(world.getFOV() * Math.PI / 360.0),
+                        b = -t,
+                        r = aspect*t,
+                        l = -r;
+
+                // calculate the object coordinates from their NDC coordinates
+                var z = -world.getViewDistance();
+
+                // unproject to get the position of the origin in GL
+                var x = -z*(r-l)/(2.0*zn)*xNDC,
+                        y = -z*(t-b)/(2.0*zn)*yNDC;
+                z = 0.0;
+
+                // transform by the object's transformation matrix
+                var glPt = MathUtils.transformPoint( [x, y, z], this.getMatrix() );
+
+                return glPt;
+        };
+
     this.buildBuffers = function () {
         // this function must be overridden by the base class
         alert("GLGeomObj.buildBuffers must be overridden by base class");
diff --git a/js/lib/geom/rectangle.js b/js/lib/geom/rectangle.js
index fcd1c1bd..490a9a6f 100755
--- a/js/lib/geom/rectangle.js
+++ b/js/lib/geom/rectangle.js
@@ -7,6 +7,7 @@
 var GeomObj = require("js/lib/geom/geom-obj").GeomObj;
 var ShapePrimitive =    require("js/lib/geom/shape-primitive").ShapePrimitive;
 var MaterialsModel = require("js/models/materials-model").MaterialsModel;
+
  ///////////////////////////////////////////////////////////////////////
 // Class GLRectangle
 //      GL representation of a rectangle.
@@ -54,6 +55,10 @@ var Rectangle = function GLRectangle() {
                         this.setBRRadius(brRadius);
 
                         this._strokeStyle = strokeStyle;
+
+                        this._matrix = Matrix.I(4);
+                        //this._matrix[12] = xoffset;
+                        //this._matrix[13] = yoffset;
                 }
 
                 // the overall radius includes the fill and the stroke.  separate the two based onthe stroke width
@@ -373,26 +378,36 @@ var Rectangle = function GLRectangle() {
         if (brRad > minDimen)  brRad = minDimen;
         if (trRad > minDimen)  trRad = minDimen;
 
+                var viewUtils = require("js/helper-classes/3D/view-utils").ViewUtils;
+                var world = this.getWorld();
+                viewUtils.pushViewportObj( world.getCanvas() );
+                var cop = viewUtils.getCenterOfProjection();
+                viewUtils.popViewportObj();
+                var xCtr = cop[0] + this._xOffset,                                      yCtr = cop[1] - this._yOffset;
+                var xLeft = xCtr - 0.5*this.getWidth(),                         yTop = yCtr - 0.5*this.getHeight();
+                var xDist = cop[0] - xLeft,                                                     yDist = cop[1] - yTop;
+                var xOff = 0.5*world.getViewportWidth() - xDist,        yOff  = 0.5*world.getViewportHeight() - yDist;
+
                 if ((tlRad <= 0) && (blRad <= 0) && (brRad <= 0) && (trRad <= 0)) {
-                        ctx.rect(pt[0], pt[1], width - 2*inset, height - 2*inset);
+                        ctx.rect(pt[0]+xOff, pt[1]+yOff, width - 2*inset, height - 2*inset);
                 } else {