Added a locked view mode for each axis in the entity editor, fixed trackball camera panning code

IDE/Contents/Include/EditorGrid.h

@@ -53,7 +53,9 @@ class EditorGrid : public Entity {
         void rebuildGrid();
 		
         static const int GRID_MODE_3D = 0;
-        static const int GRID_MODE_2D = 1;
+        static const int GRID_MODE_2D_X = 1;
+        static const int GRID_MODE_2D_Y = 2;
+        static const int GRID_MODE_2D_Z = 3;
     
 	private:
         int gridMode;

IDE/Contents/Include/PolycodeEntityEditor.h

@@ -213,9 +213,11 @@ class EntityEditorMainView : public UIElement {
     
             void setEditorPropsRecursive(Entity *entity);
     
-            static const int EDITOR_MODE_3D = 0;
-            static const int EDITOR_MODE_2D = 1;
-    
+            static const int EDITOR_MODE_2D = 0;
+            static const int EDITOR_MODE_3D_X = 1;
+            static const int EDITOR_MODE_3D_Y = 2;
+            static const int EDITOR_MODE_3D_Z = 3;
+            static const int EDITOR_MODE_3D = 4;
 		protected:
     
             bool selectingNewEntities();
@@ -260,7 +262,10 @@ class EntityEditorMainView : public UIElement {
 			EditorGrid *grid;
     
             UIImageButton *addEntityButton;
-            UIComboBox *modeSwitchDropdown;
+    
+            UIIconSelector *viewModeSelector;
+    
+    
             UIMenu *addEntityMenu;
     
             UIIconSelector *shadeModeSelector;

IDE/Contents/Include/PolycodeSpriteEditor.h

@@ -25,6 +25,7 @@
 #include "PolycodeEditor.h"
 #include <Polycode.h>
 #include "PolycodeProps.h"
+#include "TransformGizmo.h"
 
 using namespace Polycode;
 
@@ -51,42 +52,6 @@ class SpritePreview : public UIElement {
     
 };
 
-class TransformGrips : public UIElement {
-    public:
-        TransformGrips();
-        ~TransformGrips();
-    
-        void setGripRectangle(Polycode::Rectangle rectangle, Vector2 offset);
-    
-        void handleEvent(Event *event);
-        Polycode::Rectangle getGripRectangle();
-    
-        Vector2 getAnchorPoint();
-    
-    private:
-    
-        bool transforming;
-        UIImage *movingTransform;
-    
-        Polycode::Rectangle gripRectangle;
-        Vector2 anchorPoint;
-    
-        Vector2 mouseBase;
-    
-        UIRect *mainRect;
-        UIImage *transformTL;
-        UIImage *transformT;
-        UIImage *transformTR;
-        UIImage *transformR;
-        UIImage *transformL;
-        UIImage *transformBL;
-        UIImage *transformB;
-        UIImage *transformBR;
-        UIImage *transformOffset;
-        std::vector<UIElement*> grips;
-    
-};
-
 class SpriteSheetEditor : public UIElement {
     public:
         SpriteSheetEditor(SpriteSet *sprite);

IDE/Contents/Include/TrackballCamera.h

@@ -37,6 +37,7 @@ class TrackballCamera : public EventDispatcher {
 		void setCameraDistance(Number cameraDistance);
 		Camera *getTargetCamera();
     
+    
         void setCameraPosition(Vector3 cameraPosition);
     
 		bool isNavKeyDown();

IDE/Contents/Include/TransformGizmo.h

@@ -28,6 +28,43 @@
 
 using namespace Polycode;
 
+
+class TransformGrips : public UIElement {
+public:
+    TransformGrips();
+    ~TransformGrips();
+    
+    void setGripRectangle(Polycode::Rectangle rectangle, Vector2 offset);
+    
+    void handleEvent(Event *event);
+    Polycode::Rectangle getGripRectangle();
+    
+    Vector2 getAnchorPoint();
+    
+private:
+    
+    bool transforming;
+    UIImage *movingTransform;
+    
+    Polycode::Rectangle gripRectangle;
+    Vector2 anchorPoint;
+    
+    Vector2 mouseBase;
+    
+    UIRect *mainRect;
+    UIImage *transformTL;
+    UIImage *transformT;
+    UIImage *transformTR;
+    UIImage *transformR;
+    UIImage *transformL;
+    UIImage *transformBL;
+    UIImage *transformB;
+    UIImage *transformBR;
+    UIImage *transformOffset;
+    std::vector<UIElement*> grips;
+    
+};
+
 class TrasnformGizmoEvent : public Event {
     public:
         TrasnformGizmoEvent(int mode);

IDE/Contents/Source/EditorGrid.cpp

@@ -207,10 +207,23 @@ void EditorGrid::rebuildGrid() {
 
 void EditorGrid::setGridMode(int mode) {
     gridMode = mode;
-    if(gridMode == GRID_MODE_3D) {
-        grid->setPitch(90);
-    } else {
-        grid->setPitch(0);
+    switch(gridMode) {
+        case GRID_MODE_3D:
+            grid->setPitch(90);
+            grid->setYaw(0);
+        break;
+        case GRID_MODE_2D_X:
+            grid->setYaw(-90);
+            grid->setPitch(0);
+        break;
+        case GRID_MODE_2D_Y:
+            grid->setPitch(90);
+            grid->setYaw(0);
+        break;
+        case GRID_MODE_2D_Z:
+            grid->setPitch(0);
+            grid->setYaw(0);
+        break;
     }
 }
 

IDE/Contents/Source/PolycodeEntityEditor.cpp

@@ -359,6 +359,7 @@ EntityEditorMainView::EntityEditorMainView(PolycodeEditor *editor) {
     renderTextureShape->focusable = true;
     renderTextureShape->addEventListener(this, InputEvent::EVENT_MOUSEDOWN);
 
+    
     cameraPreview = new CameraPreviewWindow();
     addChild(cameraPreview);
     cameraPreview->setPosition(5, 35);
@@ -423,13 +424,16 @@ EntityEditorMainView::EntityEditorMainView(PolycodeEditor *editor) {
 	topBar->addChild(transformGizmoMenu);
     transformGizmoMenu->setPositionX(40);
     
-    modeSwitchDropdown = new UIComboBox(globalMenu, 100);
-    topBar->addChild(modeSwitchDropdown);
-    
-    modeSwitchDropdown->addComboItem("3D MODE");
-    modeSwitchDropdown->addComboItem("2D MODE");
-    modeSwitchDropdown->setSelectedIndex(0);
-    modeSwitchDropdown->addEventListener(this, UIEvent::CHANGE_EVENT);
+
+    viewModeSelector = new UIIconSelector();
+    viewModeSelector->addIcon("entityEditor/icon_cam_2d.png");
+    viewModeSelector->addIcon("entityEditor/icon_cam_x.png");
+    viewModeSelector->addIcon("entityEditor/icon_cam_y.png");
+    viewModeSelector->addIcon("entityEditor/icon_cam_z.png");
+    viewModeSelector->addIcon("entityEditor/icon_cam_3d.png");
+    topBar->addChild(viewModeSelector);
+    viewModeSelector->selectIndex(EDITOR_MODE_3D);
+    viewModeSelector->addEventListener(this, UIEvent::SELECT_EVENT);
     
     shadeModeSelector = new UIIconSelector();
     shadeModeSelector->addIcon("entityEditor/shade_full.png");
@@ -587,23 +591,49 @@ SceneRenderTexture *EntityEditorMainView::getRenderTexture() {
 
 void EntityEditorMainView::setEditorMode(int newMode) {
     editorMode = newMode;
-    if(editorMode == EDITOR_MODE_3D) {
-        mainScene->setSceneType(Scene::SCENE_3D);
-        grid->setGridMode(EditorGrid::GRID_MODE_3D);
-        transformGizmo->setGizmoMode(TransformGizmo::GIZMO_MODE_3D);
-        mainScene->getDefaultCamera()->setOrthoMode(false);
-        mainScene->getDefaultCamera()->setClippingPlanes(0.1, 1000);
-        trackballCamera->disableRotation(false);
-    } else {
-        mainScene->setSceneType(Scene::SCENE_2D);
-        mainScene->getDefaultCamera()->setOrthoMode(true);
-        mainScene->getDefaultCamera()->setClippingPlanes(-100, 100);
-        trackballCamera->setCameraPosition(trackballCamera->getOribitingCenter()+Vector3(0.0, 0.0, trackballCamera->getCameraDistance()));
-        grid->setGridMode(EditorGrid::GRID_MODE_2D);
-        transformGizmo->setGizmoMode(TransformGizmo::GIZMO_MODE_2D);
-        trackballCamera->disableRotation(true);
-        Update();
+    
+    switch(editorMode) {
+        case EDITOR_MODE_3D:
+            mainScene->setSceneType(Scene::SCENE_3D);
+            grid->setGridMode(EditorGrid::GRID_MODE_3D);
+            transformGizmo->setGizmoMode(TransformGizmo::GIZMO_MODE_3D);
+            mainScene->getDefaultCamera()->setOrthoMode(false);
+            mainScene->getDefaultCamera()->setClippingPlanes(0.1, 1000);
+            trackballCamera->disableRotation(false);
+        break;
+        case EDITOR_MODE_3D_X:
+            mainScene->setSceneType(Scene::SCENE_2D);
+            mainScene->getDefaultCamera()->setOrthoMode(true);
+            mainScene->getDefaultCamera()->setClippingPlanes(-0.1, 1000);
+            trackballCamera->setCameraPosition(trackballCamera->getOribitingCenter()+Vector3(trackballCamera->getCameraDistance(), 0.0, 0.0));
+            grid->setGridMode(EditorGrid::GRID_MODE_2D_X);
+            transformGizmo->setGizmoMode(TransformGizmo::GIZMO_MODE_2D);
+            trackballCamera->disableRotation(true);
+            Update();
+        break;
+        case EDITOR_MODE_3D_Y:
+            mainScene->setSceneType(Scene::SCENE_2D);
+            mainScene->getDefaultCamera()->setOrthoMode(true);
+            mainScene->getDefaultCamera()->setClippingPlanes(-0.1, 1000);
+            trackballCamera->setCameraPosition(trackballCamera->getOribitingCenter()+Vector3(0.001, trackballCamera->getCameraDistance(), 0.00));
+            grid->setGridMode(EditorGrid::GRID_MODE_2D_Y);
+            transformGizmo->setGizmoMode(TransformGizmo::GIZMO_MODE_2D);
+            trackballCamera->disableRotation(true);
+            Update();
+        break;
+        case EDITOR_MODE_3D_Z:
+        case EDITOR_MODE_2D:
+            mainScene->setSceneType(Scene::SCENE_2D);
+            mainScene->getDefaultCamera()->setOrthoMode(true);
+            mainScene->getDefaultCamera()->setClippingPlanes(-0.1, 1000);
+            trackballCamera->setCameraPosition(trackballCamera->getOribitingCenter()+Vector3(0.0, 0.0, trackballCamera->getCameraDistance()));
+            grid->setGridMode(EditorGrid::GRID_MODE_2D_Z);
+            transformGizmo->setGizmoMode(TransformGizmo::GIZMO_MODE_2D);
+            trackballCamera->disableRotation(true);
+            Update();
+        break;
     }
+
 }
 
 Entity *EntityEditorMainView::getSelectedEntity() {
@@ -669,11 +699,12 @@ void EntityEditorMainView::Update() {
         entitiesToSelect.clear();
     }
     
-    if(editorMode == EDITOR_MODE_2D) {
+    if(editorMode != EDITOR_MODE_3D) {
         Number aspect = renderTextureShape->getWidth() / renderTextureShape->getHeight();
         mainScene->getDefaultCamera()->setOrthoSize(trackballCamera->getCameraDistance() * aspect, trackballCamera->getCameraDistance());
     }
     
+    
     for(int i=0; i < icons.size(); i++) {
         Number scale;
         
@@ -687,7 +718,7 @@ void EntityEditorMainView::Update() {
             Vector3 parentPosition = parentEntity->getConcatenatedMatrix().getPosition();
             icons[i]->setPosition(parentPosition);
             
-            if(editorMode == EDITOR_MODE_2D) {
+            if(editorMode != EDITOR_MODE_3D) {
                 scale = trackballCamera->getCameraDistance() * 0.1;
             } else {
                 scale = mainScene->getDefaultCamera()->getPosition().distance(icons[i]->getConcatenatedMatrix().getPosition()) * 0.1;
@@ -1107,8 +1138,8 @@ void EntityEditorMainView::handleEvent(Event *event) {
         focusSelf();
     } else if(event->getDispatcher() == trackballCamera) {
         Update();
-    } else if(event->getDispatcher() == modeSwitchDropdown) {
-        setEditorMode(modeSwitchDropdown->getSelectedIndex());
+    } else if(event->getDispatcher() == viewModeSelector) {
+        setEditorMode(viewModeSelector->getSelectedIndex());
     } else if(event->getDispatcher() == globalFrame->assetBrowser) {
         if(event->getEventCode() == UIEvent::OK_EVENT) {
             if(assetSelectType == "mesh") {
@@ -1552,7 +1583,7 @@ void EntityEditorMainView::Resize(Number width, Number height) {
     footerBg->setPosition(0.0, height-30);
     bottomBar->setPosition(0.0, height-30);
     
-	modeSwitchDropdown->setPosition(width-110, 4);
+	viewModeSelector->setPosition(width-viewModeSelector->getWidth()-10.0, 3);
     
     Vector2 screenPos = renderTextureShape->getScreenPosition(globalScene->getDefaultCamera()->getProjectionMatrix(), globalScene->getDefaultCamera()->getTransformMatrix(), globalScene->getDefaultCamera()->getViewport());
     

IDE/Contents/Source/PolycodeSpriteEditor.cpp

@@ -27,142 +27,6 @@ extern UIColorPicker *globalColorPicker;
 extern PolycodeFrame *globalFrame;
 extern UIGlobalMenu *globalMenu;
 
-TransformGrips::TransformGrips() : UIElement() {
-    
-    mainRect = new UIRect(1.0, 1.0);
-    mainRect->setBlendingMode(Renderer::BLEND_MODE_NORMAL);
-    mainRect->color.setColor(0.0, 0.5, 1.0, 0.2);
-    grips.push_back(mainRect);
-    
-    transformTL = new UIImage("spriteEditor/transform_corner.png", 8, 8);
-    grips.push_back(transformTL);
-    transformT = new UIImage("spriteEditor/transform_corner.png", 8, 8);
-    grips.push_back(transformT);
-    transformTR = new UIImage("spriteEditor/transform_corner.png", 8, 8);
-    grips.push_back(transformTR);
-    transformL = new UIImage("spriteEditor/transform_corner.png", 8, 8);
-    grips.push_back(transformL);
-    transformR = new UIImage("spriteEditor/transform_corner.png", 8, 8);
-    grips.push_back(transformR);
-    transformBL = new UIImage("spriteEditor/transform_corner.png", 8, 8);
-    grips.push_back(transformBL);
-    transformB = new UIImage("spriteEditor/transform_corner.png", 8, 8);
-    grips.push_back(transformB);
-    transformBR = new UIImage("spriteEditor/transform_corner.png", 8, 8);
-    grips.push_back(transformBR);
-    transformOffset = new UIImage("spriteEditor/transform_offset.png", 12, 12);
-    grips.push_back(transformOffset);
-    
-    for(int i=0; i < grips.size(); i++) {
-        addChild(grips[i]);
-        if(grips[i] != mainRect) {
-            grips[i]->setAnchorPoint(Vector3());
-        }
-        grips[i]->addEventListener(this, InputEvent::EVENT_MOUSEDOWN);
-        grips[i]->addEventListener(this, InputEvent::EVENT_MOUSEUP);
-        grips[i]->addEventListener(this, InputEvent::EVENT_MOUSEUP_OUTSIDE);
-        grips[i]->blockMouseInput = true;
-    }
-
-    
-    Services()->getCore()->getInput()->addEventListener(this, InputEvent::EVENT_MOUSEMOVE);
-    
-    transforming = false;
-    
-    movingTransform = NULL;
-}
-
-Polycode::Rectangle TransformGrips::getGripRectangle() {
-    return gripRectangle;
-}
-
-void TransformGrips::handleEvent(Event *event) {
-    if(event->getDispatcher() == Services()->getCore()->getInput()) {
-        if(transforming) {
-            
-            Vector2 newMouse = Services()->getCore()->getInput()->getMousePosition();
-            
-            if(movingTransform == mainRect) {
-                gripRectangle.x += newMouse.x - mouseBase.x;
-                gripRectangle.y += newMouse.y - mouseBase.y;
-            } else if(movingTransform == transformTL) {
-                gripRectangle.x += newMouse.x - mouseBase.x;
-                gripRectangle.y += newMouse.y - mouseBase.y;
-                gripRectangle.w -= newMouse.x - mouseBase.x;
-                gripRectangle.h -= newMouse.y - mouseBase.y;
-            } else if(movingTransform == transformTR) {
-                gripRectangle.y += newMouse.y - mouseBase.y;
-                gripRectangle.w += newMouse.x - mouseBase.x;
-                gripRectangle.h -= newMouse.y - mouseBase.y;
-            } else if(movingTransform == transformT) {
-                gripRectangle.y += newMouse.y - mouseBase.y;
-                gripRectangle.h -= newMouse.y - mouseBase.y;
-            } else if(movingTransform == transformL) {
-                gripRectangle.x += newMouse.x - mouseBase.x;
-                gripRectangle.w -= newMouse.x - mouseBase.x;
-            } else if(movingTransform == transformR) {
-                gripRectangle.w += newMouse.x - mouseBase.x;
-            } else if(movingTransform == transformBL) {
-                gripRectangle.x += newMouse.x - mouseBase.x;
-                gripRectangle.w -= newMouse.x - mouseBase.x;
-                gripRectangle.h += newMouse.y - mouseBase.y;
-            } else if(movingTransform == transformBR) {
-                gripRectangle.w += newMouse.x - mouseBase.x;
-                gripRectangle.h += newMouse.y - mouseBase.y;
-            } else if(movingTransform == transformB) {
-                gripRectangle.h += newMouse.y - mouseBase.y;
-            } else if(movingTransform == transformOffset) {
-                anchorPoint.x += (newMouse.x - mouseBase.x) / gripRectangle.w;
-                anchorPoint.y += (newMouse.y - mouseBase.y) / gripRectangle.h;
-            }
-            
-            mouseBase = newMouse;
-            dispatchEvent(new Event(), Event::CHANGE_EVENT);
-        }
-    } else {
-        if(event->getEventCode() == InputEvent::EVENT_MOUSEDOWN) {
-            movingTransform = (UIImage*) event->getDispatcher();
-            transforming = true;
-            
-            mouseBase = Services()->getCore()->getInput()->getMousePosition();
-            
-        } else {
-            transforming = false;
-        }
-    }
-}
-
-Vector2 TransformGrips::getAnchorPoint() {
-    return anchorPoint;
-}
-
-TransformGrips::~TransformGrips() {
-    Services()->getCore()->getInput()->removeAllHandlersForListener(this);
-}
-
-void TransformGrips::setGripRectangle(Polycode::Rectangle rectangle, Vector2 offset) {
-
-    mainRect->setPosition(rectangle.x, rectangle.y);
-    mainRect->Resize(rectangle.w, rectangle.h);
-    
-    transformTL->setPosition(rectangle.x, rectangle.y);
-    transformT->setPosition(rectangle.x + (rectangle.w * 0.5), rectangle.y);
-    transformTR->setPosition(rectangle.x + (rectangle.w), rectangle.y);
-
-    transformL->setPosition(rectangle.x, rectangle.y +(rectangle.h * 0.5));
-    transformR->setPosition(rectangle.x + (rectangle.w), rectangle.y+(rectangle.h * 0.5));
-    
-    transformBL->setPosition(rectangle.x, rectangle.y+rectangle.h);
-    transformB->setPosition(rectangle.x + (rectangle.w * 0.5), rectangle.y+rectangle.h);
-    transformBR->setPosition(rectangle.x+rectangle.w, rectangle.y+rectangle.h);
-    
-    transformOffset->setPosition(rectangle.x + (rectangle.w * 0.5) + (offset.x * rectangle.w), rectangle.y + (rectangle.h * 0.5) + (offset.y * rectangle.h));
-    
-    gripRectangle = rectangle;
-    anchorPoint = offset;
-
-}
-
 SpriteSheetEditor::SpriteSheetEditor(SpriteSet *sprite) : UIElement() {
     
 	   

IDE/Contents/Source/TrackballCamera.cpp

@@ -151,8 +151,10 @@ void TrackballCamera::processMouseMovement(const Vector2 &newPosition) {
 								
 				Vector3 pan = trackballEye.crossProduct(Vector3(0.0, 1.0, 0.0)).setLength(mouseChange.x);
 				
-				pan = pan + (Vector3(0.0, 1.0, 0.0).setLength(mouseChange.y));
-				
+                Vector3 panCross = trackballEye.crossProduct(Vector3(0.0, 1.0, 0.0)).crossProduct(trackballEye);
+                
+				pan = pan + (panCross.setLength(mouseChange.y));
+                
 				targetCamera->Translate(pan);
 				orbitingCenter += pan;
 				trackBallMouseStart = trackBallMouseEnd;

IDE/Contents/Source/TransformGizmo.cpp

@@ -24,6 +24,142 @@
 
 extern UIGlobalMenu *globalMenu;
 
+TransformGrips::TransformGrips() : UIElement() {
+    
+    mainRect = new UIRect(1.0, 1.0);
+    mainRect->setBlendingMode(Renderer::BLEND_MODE_NORMAL);
+    mainRect->color.setColor(0.0, 0.5, 1.0, 0.2);
+    grips.push_back(mainRect);
+    
+    transformTL = new UIImage("spriteEditor/transform_corner.png", 8, 8);
+    grips.push_back(transformTL);
+    transformT = new UIImage("spriteEditor/transform_corner.png", 8, 8);
+    grips.push_back(transformT);
+    transformTR = new UIImage("spriteEditor/transform_corner.png", 8, 8);
+    grips.push_back(transformTR);
+    transformL = new UIImage("spriteEditor/transform_corner.png", 8, 8);
+    grips.push_back(transformL);
+    transformR = new UIImage("spriteEditor/transform_corner.png", 8, 8);
+    grips.push_back(transformR);
+    transformBL = new UIImage("spriteEditor/transform_corner.png", 8, 8);
+    grips.push_back(transformBL);
+    transformB = new UIImage("spriteEditor/transform_corner.png", 8, 8);
+    grips.push_back(transformB);
+    transformBR = new UIImage("spriteEditor/transform_corner.png", 8, 8);
+    grips.push_back(transformBR);
+    transformOffset = new UIImage("spriteEditor/transform_offset.png", 12, 12);
+    grips.push_back(transformOffset);
+    
+    for(int i=0; i < grips.size(); i++) {
+        addChild(grips[i]);
+        if(grips[i] != mainRect) {
+            grips[i]->setAnchorPoint(Vector3());
+        }
+        grips[i]->addEventListener(this, InputEvent::EVENT_MOUSEDOWN);
+        grips[i]->addEventListener(this, InputEvent::EVENT_MOUSEUP);
+        grips[i]->addEventListener(this, InputEvent::EVENT_MOUSEUP_OUTSIDE);
+        grips[i]->blockMouseInput = true;
+    }
+    
+    
+    Services()->getCore()->getInput()->addEventListener(this, InputEvent::EVENT_MOUSEMOVE);
+    
+    transforming = false;
+    
+    movingTransform = NULL;
+}
+
+Polycode::Rectangle TransformGrips::getGripRectangle() {
+    return gripRectangle;
+}
+
+void TransformGrips::handleEvent(Event *event) {
+    if(event->getDispatcher() == Services()->getCore()->getInput()) {
+        if(transforming) {
+            
+            Vector2 newMouse = Services()->getCore()->getInput()->getMousePosition();
+            
+            if(movingTransform == mainRect) {
+                gripRectangle.x += newMouse.x - mouseBase.x;
+                gripRectangle.y += newMouse.y - mouseBase.y;
+            } else if(movingTransform == transformTL) {
+                gripRectangle.x += newMouse.x - mouseBase.x;
+                gripRectangle.y += newMouse.y - mouseBase.y;
+                gripRectangle.w -= newMouse.x - mouseBase.x;
+                gripRectangle.h -= newMouse.y - mouseBase.y;
+            } else if(movingTransform == transformTR) {
+                gripRectangle.y += newMouse.y - mouseBase.y;
+                gripRectangle.w += newMouse.x - mouseBase.x;
+                gripRectangle.h -= newMouse.y - mouseBase.y;
+            } else if(movingTransform == transformT) {
+                gripRectangle.y += newMouse.y - mouseBase.y;
+                gripRectangle.h -= newMouse.y - mouseBase.y;
+            } else if(movingTransform == transformL) {
+                gripRectangle.x += newMouse.x - mouseBase.x;
+                gripRectangle.w -= newMouse.x - mouseBase.x;
+            } else if(movingTransform == transformR) {
+                gripRectangle.w += newMouse.x - mouseBase.x;
+            } else if(movingTransform == transformBL) {
+                gripRectangle.x += newMouse.x - mouseBase.x;
+                gripRectangle.w -= newMouse.x - mouseBase.x;
+                gripRectangle.h += newMouse.y - mouseBase.y;
+            } else if(movingTransform == transformBR) {
+                gripRectangle.w += newMouse.x - mouseBase.x;
+                gripRectangle.h += newMouse.y - mouseBase.y;
+            } else if(movingTransform == transformB) {
+                gripRectangle.h += newMouse.y - mouseBase.y;
+            } else if(movingTransform == transformOffset) {
+                anchorPoint.x += (newMouse.x - mouseBase.x) / gripRectangle.w;
+                anchorPoint.y += (newMouse.y - mouseBase.y) / gripRectangle.h;
+            }
+            
+            mouseBase = newMouse;
+            dispatchEvent(new Event(), Event::CHANGE_EVENT);
+        }
+    } else {
+        if(event->getEventCode() == InputEvent::EVENT_MOUSEDOWN) {
+            movingTransform = (UIImage*) event->getDispatcher();
+            transforming = true;
+            
+            mouseBase = Services()->getCore()->getInput()->getMousePosition();
+            
+        } else {
+            transforming = false;
+        }
+    }
+}
+
+Vector2 TransformGrips::getAnchorPoint() {
+    return anchorPoint;
+}
+
+TransformGrips::~TransformGrips() {
+    Services()->getCore()->getInput()->removeAllHandlersForListener(this);
+}
+
+void TransformGrips::setGripRectangle(Polycode::Rectangle rectangle, Vector2 offset) {
+    
+    mainRect->setPosition(rectangle.x, rectangle.y);
+    mainRect->Resize(rectangle.w, rectangle.h);
+    
+    transformTL->setPosition(rectangle.x, rectangle.y);
+    transformT->setPosition(rectangle.x + (rectangle.w * 0.5), rectangle.y);
+    transformTR->setPosition(rectangle.x + (rectangle.w), rectangle.y);
+    
+    transformL->setPosition(rectangle.x, rectangle.y +(rectangle.h * 0.5));
+    transformR->setPosition(rectangle.x + (rectangle.w), rectangle.y+(rectangle.h * 0.5));
+    
+    transformBL->setPosition(rectangle.x, rectangle.y+rectangle.h);
+    transformB->setPosition(rectangle.x + (rectangle.w * 0.5), rectangle.y+rectangle.h);
+    transformBR->setPosition(rectangle.x+rectangle.w, rectangle.y+rectangle.h);
+    
+    transformOffset->setPosition(rectangle.x + (rectangle.w * 0.5) + (offset.x * rectangle.w), rectangle.y + (rectangle.h * 0.5) + (offset.y * rectangle.h));
+    
+    gripRectangle = rectangle;
+    anchorPoint = offset;
+    
+}
+
 TrasnformGizmoEvent::TrasnformGizmoEvent(int mode) : Event() {
     this->mode =  mode;
     this->eventCode = eventCode;