ViewportTransform: Fix precision loss

All the transform calculationis are being done with integers which
could lead to precision loss. Instead we should be using floats.

diff --git a/LayerManagerPlugins/Renderers/Graphic/include/Transformation/ViewportTransform.h b/LayerManagerPlugins/Renderers/Graphic/include/Transformation/ViewportTransform.h
index c22f259..f3b1641 100644 (file)
--- a/LayerManagerPlugins/Renderers/Graphic/include/Transformation/ViewportTransform.h
+++ b/LayerManagerPlugins/Renderers/Graphic/include/Transformation/ViewportTransform.h
@@ -35,19 +35,19 @@ public:
     /*
      * Apply Source View of Layer to the given surface source and destination regions, ie cropping surface parts to layer source view
      */
-    static void applyLayerSource(const Rectangle& layerSource, Rectangle& surfaceSource, Rectangle& surfaceDestination);
+    static void applyLayerSource(const FloatRectangle& layerSource, FloatRectangle& surfaceSource, FloatRectangle& surfaceDestination);
 
     /*
      * Apply Destination View of Layer to the given surface destination region, ie scale and movement relative to scaling and position of layer
      */
-    static void applyLayerDestination(const Rectangle& layerDestination, const Rectangle& layerSource, Rectangle& regionToScale);
+    static void applyLayerDestination(const FloatRectangle& layerDestination, const FloatRectangle& layerSource, FloatRectangle& regionToScale);
 
     /*
      * Calculate Texture Coordinates as relation of the given rectangle to original values.
      * Example: x position of 10 with an original width of 40 will yield a texture coordinate of 10/40=0.25f.
      * This function expects textureCoordinates to be an allocated float array of size 4, in which the texture coordinates will be returned.
      */
-    static void transformRectangleToTextureCoordinates(const Rectangle& rectangle, uint originalWidth, uint originalHeight, float* textureCoordinates);
+    static void transformRectangleToTextureCoordinates(const FloatRectangle& rectangle, const float originalWidth, const float originalHeight, float* textureCoordinates);
 };
 
 #endif /* _VIEWPORT_TRANSFORM_H_ */

diff --git a/LayerManagerPlugins/Renderers/Graphic/src/GraphicSystems/GLESGraphicSystem.cpp b/LayerManagerPlugins/Renderers/Graphic/src/GraphicSystems/GLESGraphicSystem.cpp
index 499f9e9..da35f54 100644 (file)
--- a/LayerManagerPlugins/Renderers/Graphic/src/GraphicSystems/GLESGraphicSystem.cpp
+++ b/LayerManagerPlugins/Renderers/Graphic/src/GraphicSystems/GLESGraphicSystem.cpp
@@ -295,12 +295,12 @@ void GLESGraphicsystem::renderSurface(Surface* surface)
         // use layer shader if no custom shader is assigned to this surface
         shader = layerShader;
     }
-    const Rectangle& layerDestinationRegion = (m_currentLayer)->getDestinationRegion();
-    const Rectangle& layerSourceRegion = (m_currentLayer)->getSourceRegion();
 
-    // these variables contain the current calculated values of the surface
-    Rectangle targetSurfaceSource = surface->getSourceRegion();
-    Rectangle targetSurfaceDestination = surface->getDestinationRegion();
+    const FloatRectangle layerSourceRegion = m_currentLayer->getSourceRegion();
+    const FloatRectangle layerDestinationRegion = m_currentLayer->getDestinationRegion();
+
+    FloatRectangle targetSurfaceSource = surface->getSourceRegion();
+    FloatRectangle targetSurfaceDestination = surface->getDestinationRegion();
 
     ViewportTransform::applyLayerSource(layerSourceRegion, targetSurfaceSource, targetSurfaceDestination);
     ViewportTransform::applyLayerDestination(layerDestinationRegion, layerSourceRegion, targetSurfaceDestination);
@@ -308,12 +308,12 @@ void GLESGraphicsystem::renderSurface(Surface* surface)
     ViewportTransform::transformRectangleToTextureCoordinates(targetSurfaceSource, surface->OriginalSourceWidth, surface->OriginalSourceHeight, textureCoordinates);
 
     glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
-       applyLayerMatrix(layerMatrix);
+    applyLayerMatrix(layerMatrix);
     // update all common uniforms, scale values to display size
-    uniforms.x = (float)targetSurfaceDestination.x / m_displayWidth;
-    uniforms.y = (float)targetSurfaceDestination.y / m_displayHeight;;
-    uniforms.width = (float)targetSurfaceDestination.width / m_displayWidth;
-    uniforms.height = (float)targetSurfaceDestination.height / m_displayHeight;
+    uniforms.x = targetSurfaceDestination.x / m_displayWidth;
+    uniforms.y = targetSurfaceDestination.y / m_displayHeight;;
+    uniforms.width = targetSurfaceDestination.width / m_displayWidth;
+    uniforms.height = targetSurfaceDestination.height / m_displayHeight;
     uniforms.opacity = (surface)->getOpacity() * m_currentLayer->getOpacity();
     uniforms.texRange[0] = (textureCoordinates[1]-textureCoordinates[0]);
     uniforms.texRange[1] = (textureCoordinates[3]-textureCoordinates[2]);

diff --git a/LayerManagerPlugins/Renderers/Graphic/src/GraphicSystems/GLXGraphicSystem.cpp b/LayerManagerPlugins/Renderers/Graphic/src/GraphicSystems/GLXGraphicSystem.cpp
index 01fac43..ea1d8c6 100644 (file)
--- a/LayerManagerPlugins/Renderers/Graphic/src/GraphicSystems/GLXGraphicSystem.cpp
+++ b/LayerManagerPlugins/Renderers/Graphic/src/GraphicSystems/GLXGraphicSystem.cpp
@@ -319,30 +319,31 @@ void GLXGraphicsystem::renderSurface(Surface* currentSurface)
 {
 //    LOG_DEBUG("GLXGraphicsystem", "renderSurface " << currentSurface->getID() );
     GLenum glErrorCode = GL_NO_ERROR;
-    const Rectangle &layerDestinationRegion = (m_currentLayer)->getDestinationRegion();
-    const Rectangle &layerSourceRegion = (m_currentLayer)->getSourceRegion();
-    
-    Rectangle targetSurfaceSource = currentSurface->getSourceRegion();
-    Rectangle targetSurfaceDestination = currentSurface->getDestinationRegion();
 
     // check if surface is cropped completely, if so then skip rendering
-    if (ViewportTransform::isFullyCropped(targetSurfaceDestination, layerSourceRegion ) )
+    if (ViewportTransform::isFullyCropped(currentSurface->getDestinationRegion(), m_currentLayer->getSourceRegion() ) )
         return; // skip rendering of this surface, because it is cropped by layer source region
 
+    const FloatRectangle layerSourceRegion = m_currentLayer->getSourceRegion();
+    const FloatRectangle layerDestinationRegion = m_currentLayer->getDestinationRegion();
+
+    FloatRectangle targetSurfaceSource = currentSurface->getSourceRegion();
+    FloatRectangle targetSurfaceDestination = currentSurface->getDestinationRegion();
+
     ViewportTransform::applyLayerSource(layerSourceRegion, targetSurfaceSource, targetSurfaceDestination);
     ViewportTransform::applyLayerDestination(layerDestinationRegion, layerSourceRegion, targetSurfaceDestination);
     float textureCoordinates[4];
     ViewportTransform::transformRectangleToTextureCoordinates(targetSurfaceSource, currentSurface->OriginalSourceWidth, currentSurface->OriginalSourceHeight, textureCoordinates);
-    
+
     glPushMatrix();
-    if (false == m_binder->bindSurfaceTexture(currentSurface)) 
-    {   
-        /* skip render surface if not bind successfully */        
+    if (false == m_binder->bindSurfaceTexture(currentSurface))
+    {
+        /* skip render surface if not bind successfully */
         return;
     }
 //    glPushMatrix();
     glColor4f(1.0f,1.0f,1.0f,currentSurface->opacity*(m_currentLayer)->opacity);
-       
+
     glBegin(GL_QUADS);
 
 //    LOG_DEBUG("GLXGraphicsystem","rendersurface: src" << src.x << " " << src.y << " " << src.width << " " << src.height );

diff --git a/LayerManagerPlugins/Renderers/Graphic/src/Transformation/ViewportTransform.cpp b/LayerManagerPlugins/Renderers/Graphic/src/Transformation/ViewportTransform.cpp
index d568c8d..bee67bd 100644 (file)
--- a/LayerManagerPlugins/Renderers/Graphic/src/Transformation/ViewportTransform.cpp
+++ b/LayerManagerPlugins/Renderers/Graphic/src/Transformation/ViewportTransform.cpp
@@ -36,24 +36,24 @@ bool ViewportTransform::isFullyCropped(const Rectangle& surfaceDestination, cons
     return false;
 }
 
-void ViewportTransform::applyLayerSource(const Rectangle& layerSource, Rectangle& surfaceSource, Rectangle& surfaceDestination)
+void ViewportTransform::applyLayerSource(const FloatRectangle& layerSource, FloatRectangle& surfaceSource, FloatRectangle& surfaceDestination)
 {
-    int cropamount = 0;
-    float surfaceInverseScaleX = (float)surfaceSource.width / surfaceDestination.width;
-    float surfaceInverseScaleY = (float)surfaceSource.height / surfaceDestination.height;
+    float cropamount = 0;
+    float surfaceInverseScaleX = surfaceSource.width / surfaceDestination.width;
+    float surfaceInverseScaleY = surfaceSource.height / surfaceDestination.height;
 
     // X
 
     // Crop from left
     cropamount = layerSource.x - surfaceDestination.x;
-    if (cropamount > 0)
+    if (cropamount > 0.0f)
     {
-        surfaceDestination.x = 0;
+        surfaceDestination.x = 0.0f;
         surfaceDestination.width -= cropamount;
 
         // crop a proportional part of the source region
-        surfaceSource.x += (float)cropamount * surfaceInverseScaleX;
-        surfaceSource.width -= (float)cropamount * surfaceInverseScaleX;
+        surfaceSource.x += cropamount * surfaceInverseScaleX;
+        surfaceSource.width -= cropamount * surfaceInverseScaleX;
     }
     else
     {
@@ -62,26 +62,26 @@ void ViewportTransform::applyLayerSource(const Rectangle& layerSource, Rectangle
 
     // Crop from right
     cropamount = surfaceDestination.x + surfaceDestination.width - layerSource.width;
-    if (cropamount > 0)
+    if (cropamount > 0.0f)
     {
         surfaceDestination.width -= cropamount;
 
         // crop a proportional part of the source region
-        surfaceSource.width -= (float)cropamount * surfaceInverseScaleX;
+        surfaceSource.width -= cropamount * surfaceInverseScaleX;
     }
 
     // Y
 
     // Crop from top
     cropamount = layerSource.y - surfaceDestination.y;
-    if (cropamount > 0)
+    if (cropamount > 0.0f)
     {
-        surfaceDestination.y = 0;
+        surfaceDestination.y = 0.0f;
         surfaceDestination.height -= cropamount;
 
         // crop a proportional part of the source region
-        surfaceSource.y += (float)cropamount * surfaceInverseScaleY;
-        surfaceSource.height -= (float)cropamount * surfaceInverseScaleY;
+        surfaceSource.y += cropamount * surfaceInverseScaleY;
+        surfaceSource.height -= cropamount * surfaceInverseScaleY;
     }
     else
     {
@@ -90,53 +90,53 @@ void ViewportTransform::applyLayerSource(const Rectangle& layerSource, Rectangle
 
     // Crop from bottom
     cropamount = surfaceDestination.y + surfaceDestination.height - layerSource.height;
-    if (cropamount > 0)
+    if (cropamount > 0.0f)
     {
         surfaceDestination.height -= cropamount;
 
         // crop a proportional part of the source region
-        surfaceSource.height -= (float)cropamount * surfaceInverseScaleY;
+        surfaceSource.height -= cropamount * surfaceInverseScaleY;
     }
 }
 
-void ViewportTransform::applyLayerDestination(const Rectangle& layerDestination, const Rectangle& layerSource, Rectangle& regionToScale)
+void ViewportTransform::applyLayerDestination(const FloatRectangle& layerDestination, const FloatRectangle& layerSource, FloatRectangle& regionToScale)
 {
-    // scale position proportional to change in layer size
-    regionToScale.x *= (float)layerDestination.width/layerSource.width;
+    float scaleX = layerDestination.width / layerSource.width;
+    float scaleY = layerDestination.height / layerSource.height;
+
+    // scale position proportional to change in float*layer size
+    regionToScale.x *= scaleX;
     // scale width proportional to change in layer size
-    regionToScale.width *= (float)layerDestination.width/layerSource.width;
+    regionToScale.width *= scaleX;
     // after scaling, move surface because its position should be relative to moved layer
-    regionToScale.x+=layerDestination.x;
+    regionToScale.x += layerDestination.x;
 
     // scale position proportional to change in layer size
-    regionToScale.y *= (float)layerDestination.height/layerSource.height;
+    regionToScale.y *= scaleY;
     // scale width proportional to change in layer size
-    regionToScale.height *= (float)layerDestination.height/layerSource.height;
+    regionToScale.height *= scaleY;
     // after scaling, move surface because its position should be relative to moved layer
-    regionToScale.y+=layerDestination.y;
+    regionToScale.y += layerDestination.y;
 }
 
-void ViewportTransform::transformRectangleToTextureCoordinates(const Rectangle& rectangle, uint originalWidth, uint originalHeight, float* textureCoordinates)
+void ViewportTransform::transformRectangleToTextureCoordinates(const FloatRectangle& rectangle, const float originalWidth, const float originalHeight, float* textureCoordinates)
 {
-    float originalWidthAsFloat = originalWidth;
-    float originalHeightAsFloat = originalHeight;
-
     // move texture coordinate proportional to the cropped pixels
-    float percentageCroppedFromLowerSide_U = rectangle.x/originalWidthAsFloat;
-    textureCoordinates[0] = percentageCroppedFromLowerSide_U;
+    float percentageCroppedFromLeftSide = rectangle.x / originalWidth;
+    textureCoordinates[0] = percentageCroppedFromLeftSide;
 
     // move texture coordinate proportional to the cropped pixels
-    uint newRightSide = rectangle.x+rectangle.width;
-    float percentageCroppedFromRightSide = (originalWidthAsFloat-newRightSide)/originalWidthAsFloat;
-    textureCoordinates[1] = 1.0f-percentageCroppedFromRightSide ;
+    uint newRightSide = rectangle.x + rectangle.width;
+    float percentageCroppedFromRightSide = (originalWidth - newRightSide) / originalWidth;
+    textureCoordinates[1] = 1.0f - percentageCroppedFromRightSide;
 
     // the same for Y
     // move texture coordinate proportional to the cropped pixels
-    float percentageCroppedFromTopSideV = ((float)rectangle.y/originalHeightAsFloat);
-    textureCoordinates[2] = percentageCroppedFromTopSideV;
+    float percentageCroppedFromTopSide = rectangle.y / originalHeight;
+    textureCoordinates[2] = percentageCroppedFromTopSide;
 
     // move texture coordinate proportional to the cropped pixels
-    int newBottomSide = rectangle.y+rectangle.height;
-    float percentageCroppedFromBottomSide = (float)(originalHeightAsFloat-newBottomSide)/originalHeightAsFloat;
-    textureCoordinates[3] = 1.0f-percentageCroppedFromBottomSide ;
+    int newBottomSide = rectangle.y + rectangle.height;
+    float percentageCroppedFromBottomSide = (originalHeight - newBottomSide) / originalHeight;
+    textureCoordinates[3] = 1.0f - percentageCroppedFromBottomSide;
 }

diff --git a/LayerManagerPlugins/Renderers/Graphic/tests/ViewportTransformTest.cpp b/LayerManagerPlugins/Renderers/Graphic/tests/ViewportTransformTest.cpp
index be34dcf..29fcc09 100644 (file)
--- a/LayerManagerPlugins/Renderers/Graphic/tests/ViewportTransformTest.cpp
+++ b/LayerManagerPlugins/Renderers/Graphic/tests/ViewportTransformTest.cpp
@@ -27,7 +27,7 @@
 class ViewportTransformTest : public ::testing::Test {
 public:
 
-       ViewportTransformTest()
+    ViewportTransformTest()
     {
     }
 
@@ -46,49 +46,48 @@ public:
 // LAYER SOURCE TRANSFORMATION
 
 TEST_F(ViewportTransformTest, doLayerSRCSurfaceCompletelyWithin){
-    Rectangle targetSurfaceSource(0,0,10,10);
-    Rectangle targetSurfaceDest(20,20,10,10);
-    Rectangle layerSRC(10,10,30,30);
+    FloatRectangle targetSurfaceSrc = FloatRectangle(0,0,10,10);
+    FloatRectangle targetSurfaceDest = FloatRectangle(20,20,10,10);
+    FloatRectangle layerSRC = FloatRectangle(10,10,30,30);
 
-    ViewportTransform::applyLayerSource(layerSRC,targetSurfaceSource, targetSurfaceDest);
-    ASSERT_EQ(10u, targetSurfaceDest.x);
-    ASSERT_EQ(10u, targetSurfaceDest.width);
-    ASSERT_EQ(10u, targetSurfaceDest.y);
-    ASSERT_EQ(10u, targetSurfaceDest.height);
+    ViewportTransform::applyLayerSource(layerSRC,targetSurfaceSrc,targetSurfaceDest);
+    ASSERT_EQ(10.0, targetSurfaceDest.x);
+    ASSERT_EQ(10.0, targetSurfaceDest.width);
+    ASSERT_EQ(10.0, targetSurfaceDest.y);
+    ASSERT_EQ(10.0, targetSurfaceDest.height);
 
-    ASSERT_EQ(0u, targetSurfaceSource.x);
-    ASSERT_EQ(10u, targetSurfaceSource.width);
-    ASSERT_EQ(0u, targetSurfaceSource.y);
-    ASSERT_EQ(10u, targetSurfaceSource.height);
+    ASSERT_EQ(0.0, targetSurfaceSrc.x);
+    ASSERT_EQ(10.0, targetSurfaceSrc.width);
+    ASSERT_EQ(0.0, targetSurfaceSrc.y);
+    ASSERT_EQ(10.0, targetSurfaceSrc.height);
 
 }
 
 TEST_F(ViewportTransformTest, doLayerSRCSurfaceCroppedFromLeft){
     uint surfaceOriginalWidth = 20;
     uint surfaceOriginalHeight = 20;
-    Rectangle targetSurfaceSrc(0,0,20,20);
-    Rectangle targetSurfaceDest(20,20,20,20);
-    Rectangle layerSRC(30,30,20,20);
+    FloatRectangle targetSurfaceSrc = FloatRectangle(0,0,20,20);
+    FloatRectangle targetSurfaceDest = FloatRectangle(20,20,20,20);
+    FloatRectangle layerSRC = FloatRectangle(30,30,20,20);
     ViewportTransform::applyLayerSource(layerSRC,targetSurfaceSrc,targetSurfaceDest);
     float* textureCoordinates = new float[4];
-    new float[4];
     ViewportTransform::transformRectangleToTextureCoordinates(targetSurfaceSrc, surfaceOriginalWidth, surfaceOriginalHeight, textureCoordinates);
     ASSERT_EQ(0.5,textureCoordinates[0]);
     ASSERT_EQ(1.0,textureCoordinates[1]);
     ASSERT_EQ(0.5,textureCoordinates[2]);
     ASSERT_EQ(1.0,textureCoordinates[3]);
-    ASSERT_EQ(0u, targetSurfaceDest.x);
-    ASSERT_EQ(10u, targetSurfaceDest.width);
-    ASSERT_EQ(0u, targetSurfaceDest.y);
-    ASSERT_EQ(10u, targetSurfaceDest.height);
+    ASSERT_EQ(0.0, targetSurfaceDest.x);
+    ASSERT_EQ(10.0, targetSurfaceDest.width);
+    ASSERT_EQ(0.0, targetSurfaceDest.y);
+    ASSERT_EQ(10.0, targetSurfaceDest.height);
 }
 
 TEST_F(ViewportTransformTest, doLayerSRCSurfaceCroppedFromRight){
     uint surfaceOriginalWidth = 20;
     uint surfaceOriginalHeight = 20;
-    Rectangle targetSurfaceSrc(0,0,20,20);
-    Rectangle targetSurfaceDest(20,20,20,20);
-    Rectangle layerSRC(0,0,35,35);
+    FloatRectangle targetSurfaceSrc = FloatRectangle(0,0,20,20);
+    FloatRectangle targetSurfaceDest = FloatRectangle(20,20,20,20);
+    FloatRectangle layerSRC = FloatRectangle(0,0,35,35);
 
     ViewportTransform::applyLayerSource(layerSRC,targetSurfaceSrc,targetSurfaceDest);
     float* textureCoordinates = new float[4];
@@ -97,18 +96,18 @@ TEST_F(ViewportTransformTest, doLayerSRCSurfaceCroppedFromRight){
     ASSERT_EQ(0.75,textureCoordinates[1]);
     ASSERT_EQ(0,textureCoordinates[2]);
     ASSERT_EQ(0.75,textureCoordinates[3]);
-    ASSERT_EQ(20u, targetSurfaceDest.x);
-    ASSERT_EQ(15u, targetSurfaceDest.width);
-    ASSERT_EQ(20u, targetSurfaceDest.y);
-    ASSERT_EQ(15u, targetSurfaceDest.height);
+    ASSERT_EQ(20.0, targetSurfaceDest.x);
+    ASSERT_EQ(15.0, targetSurfaceDest.width);
+    ASSERT_EQ(20.0, targetSurfaceDest.y);
+    ASSERT_EQ(15.0, targetSurfaceDest.height);
 }
 
 TEST_F(ViewportTransformTest, doLayerSRCSurfaceCroppedFromBothSides){
     uint surfaceOriginalWidth = 20;
     uint surfaceOriginalHeight = 20;
-    Rectangle targetSurfaceSrc(0,0,20,20);
-    Rectangle targetSurfaceDest(20,20,20,20);
-    Rectangle layerSRC(25,25,10,10);
+    FloatRectangle targetSurfaceSrc = FloatRectangle(0,0,20,20);
+    FloatRectangle targetSurfaceDest = FloatRectangle(20,20,20,20);
+    FloatRectangle layerSRC = FloatRectangle(25,25,10,10);
 
     ViewportTransform::applyLayerSource(layerSRC,targetSurfaceSrc,targetSurfaceDest);
     float* textureCoordinates = new float[4];
@@ -117,21 +116,21 @@ TEST_F(ViewportTransformTest, doLayerSRCSurfaceCroppedFromBothSides){
     ASSERT_EQ(0.75,textureCoordinates[1]);
     ASSERT_EQ(0.25,textureCoordinates[2]);
     ASSERT_EQ(0.75,textureCoordinates[3]);
-    ASSERT_EQ(0u, targetSurfaceDest.x);
-    ASSERT_EQ(10u, targetSurfaceDest.width);
-    ASSERT_EQ(0u, targetSurfaceDest.y);
-    ASSERT_EQ(10u, targetSurfaceDest.height);
+    ASSERT_EQ(0.0, targetSurfaceDest.x);
+    ASSERT_EQ(10.0, targetSurfaceDest.width);
+    ASSERT_EQ(0.0, targetSurfaceDest.y);
+    ASSERT_EQ(10.0, targetSurfaceDest.height);
 }
 
-       // LAYER DESTINATION TRANSFORMATION
+// LAYER DESTINATION TRANSFORMATION
 
 TEST_F(ViewportTransformTest, doLayerDESTScaleUp){
     uint surfaceOriginalWidth = 20;
     uint surfaceOriginalHeight = 20;
-    Rectangle targetSurfaceSrc(0,0,20,20);
-    Rectangle targetSurfaceDest(10,10,100,100);
-    Rectangle layerSrc(0,0,200,200);
-    Rectangle layerDest(50,50,600,600);
+    FloatRectangle targetSurfaceSrc = FloatRectangle(0,0,20,20);
+    FloatRectangle targetSurfaceDest = FloatRectangle(10,10,100,100);
+    FloatRectangle layerSrc = FloatRectangle(0,0,200,200);
+    FloatRectangle layerDest = FloatRectangle(50,50,600,600);
 
     ViewportTransform::applyLayerDestination(layerDest,layerSrc,targetSurfaceDest);
     float* textureCoordinates = new float[4];
@@ -140,19 +139,19 @@ TEST_F(ViewportTransformTest, doLayerDESTScaleUp){
     ASSERT_EQ(1.0,textureCoordinates[1]);
     ASSERT_EQ(0.0,textureCoordinates[2]);
     ASSERT_EQ(1.0,textureCoordinates[3]);
-    ASSERT_EQ(30u+50u, targetSurfaceDest.x);
-    ASSERT_EQ(300u, targetSurfaceDest.width);
-    ASSERT_EQ(30u+50u, targetSurfaceDest.y);
-    ASSERT_EQ(300u, targetSurfaceDest.height);
+    ASSERT_EQ(80.0, targetSurfaceDest.x);
+    ASSERT_EQ(300.0, targetSurfaceDest.width);
+    ASSERT_EQ(80.0, targetSurfaceDest.y);
+    ASSERT_EQ(300.0, targetSurfaceDest.height);
 }
 
 TEST_F(ViewportTransformTest, doLayerDESTScaleDown){
     uint surfaceOriginalWidth = 20;
     uint surfaceOriginalHeight = 20;
-    Rectangle targetSurfaceSrc(0,0,20,20);
-    Rectangle targetSurfaceDest(10,10,100,100);
-    Rectangle layerSRC(0,0,200,200);
-    Rectangle layerDest(50,50,20,20);
+    FloatRectangle targetSurfaceSrc = FloatRectangle(0,0,20,20);
+    FloatRectangle targetSurfaceDest = FloatRectangle(10,10,100,100);
+    FloatRectangle layerSRC = FloatRectangle(0,0,200,200);
+    FloatRectangle layerDest = FloatRectangle(50,50,20,20);
 
     ViewportTransform::applyLayerDestination(layerDest,layerSRC,targetSurfaceDest);
     float* textureCoordinates = new float[4];
@@ -161,19 +160,19 @@ TEST_F(ViewportTransformTest, doLayerDESTScaleDown){
     ASSERT_EQ(1.0,textureCoordinates[1]);
     ASSERT_EQ(0.0,textureCoordinates[2]);
     ASSERT_EQ(1.0,textureCoordinates[3]);
-    ASSERT_EQ(1u+50u, targetSurfaceDest.x);
-    ASSERT_EQ(10u, targetSurfaceDest.width);
-    ASSERT_EQ(1u+50u, targetSurfaceDest.y);
-    ASSERT_EQ(10u, targetSurfaceDest.height);
+    ASSERT_EQ(51.0, targetSurfaceDest.x);
+    ASSERT_EQ(10.0, targetSurfaceDest.width);
+    ASSERT_EQ(51.0, targetSurfaceDest.y);
+    ASSERT_EQ(10.0, targetSurfaceDest.height);
 }
 
 
 TEST_F(ViewportTransformTest, doLayerSRCTransformationTest1){
     uint surfaceOriginalWidth = 10;
     uint surfaceOriginalHeight = 10;
-    Rectangle targetSurfaceSrc(0,0,10,10);
-    Rectangle targetSurfaceDest(20,20,10,10);
-    Rectangle layerSRC(25,25,75,75);
+    FloatRectangle targetSurfaceSrc = FloatRectangle(0,0,10,10);
+    FloatRectangle targetSurfaceDest = FloatRectangle(20,20,10,10);
+    FloatRectangle layerSRC = FloatRectangle(25,25,75,75);
 
     ViewportTransform::applyLayerSource(layerSRC,targetSurfaceSrc,targetSurfaceDest);
     float* textureCoordinates = new float[4];
@@ -182,18 +181,18 @@ TEST_F(ViewportTransformTest, doLayerSRCTransformationTest1){
     ASSERT_NEAR(1.0,textureCoordinates[1],0.01);
     ASSERT_NEAR(0.5,textureCoordinates[2],0.01);
     ASSERT_NEAR(1.0,textureCoordinates[3],0.01);
-    ASSERT_EQ(0u, targetSurfaceDest.x);
-    ASSERT_EQ(5u, targetSurfaceDest.width);
-    ASSERT_EQ(0u, targetSurfaceDest.y);
-    ASSERT_EQ(5u, targetSurfaceDest.height);
+    ASSERT_EQ(0.0, targetSurfaceDest.x);
+    ASSERT_EQ(5.0, targetSurfaceDest.width);
+    ASSERT_EQ(0.0, targetSurfaceDest.y);
+    ASSERT_EQ(5.0, targetSurfaceDest.height);
 }
 
 TEST_F(ViewportTransformTest, doLayerSRCTransformationTest2){
     uint surfaceOriginalWidth = 20;
     uint surfaceOriginalHeight = 20;
-    Rectangle targetSurfaceSrc(0,0,20,20);
-    Rectangle targetSurfaceDest(30,30,30,30);
-    Rectangle layerSRC(25,25,75,75);
+    FloatRectangle targetSurfaceSrc = FloatRectangle(0,0,20,20);
+    FloatRectangle targetSurfaceDest = FloatRectangle(30,30,30,30);
+    FloatRectangle layerSRC = FloatRectangle(25,25,75,75);
 
     ViewportTransform::applyLayerSource(layerSRC,targetSurfaceSrc,targetSurfaceDest);
     float* textureCoordinates = new float[4];
@@ -202,18 +201,18 @@ TEST_F(ViewportTransformTest, doLayerSRCTransformationTest2){
     ASSERT_NEAR(1.0,textureCoordinates[1],0.01);
     ASSERT_NEAR(0.0,textureCoordinates[2],0.01);
     ASSERT_NEAR(1.0,textureCoordinates[3],0.01);
-    ASSERT_EQ(5u, targetSurfaceDest.x);
-    ASSERT_EQ(30u, targetSurfaceDest.width);
-    ASSERT_EQ(5u, targetSurfaceDest.y);
-    ASSERT_EQ(30u, targetSurfaceDest.height);
+    ASSERT_EQ(5.0, targetSurfaceDest.x);
+    ASSERT_EQ(30.0, targetSurfaceDest.width);
+    ASSERT_EQ(5.0, targetSurfaceDest.y);
+    ASSERT_EQ(30.0, targetSurfaceDest.height);
 }
 
 TEST_F(ViewportTransformTest, doLayerSRCTransformationTest3){
     uint surfaceOriginalWidth = 10;
     uint surfaceOriginalHeight = 10;
-    Rectangle targetSurfaceSrc(0,0,10,10);
-    Rectangle targetSurfaceDest(70,70,10,10);
-    Rectangle layerSRC(25,25,50,50);
+    FloatRectangle targetSurfaceSrc = FloatRectangle(0,0,10,10);
+    FloatRectangle targetSurfaceDest = FloatRectangle(70,70,10,10);
+    FloatRectangle layerSRC = FloatRectangle(25,25,50,50);
 
     ViewportTransform::applyLayerSource(layerSRC,targetSurfaceSrc,targetSurfaceDest);
     float* textureCoordinates = new float[4];
@@ -222,18 +221,18 @@ TEST_F(ViewportTransformTest, doLayerSRCTransformationTest3){
     ASSERT_NEAR(0.5,textureCoordinates[1],0.01);
     ASSERT_NEAR(0.0,textureCoordinates[2],0.01);
     ASSERT_NEAR(0.5,textureCoordinates[3],0.01);
-    ASSERT_EQ(45u, targetSurfaceDest.x);
-    ASSERT_EQ(5u, targetSurfaceDest.width);
-    ASSERT_EQ(45u, targetSurfaceDest.y);
-    ASSERT_EQ(5u, targetSurfaceDest.height);
+    ASSERT_EQ(45.0, targetSurfaceDest.x);
+    ASSERT_EQ(5.0, targetSurfaceDest.width);
+    ASSERT_EQ(45.0, targetSurfaceDest.y);
+    ASSERT_EQ(5.0, targetSurfaceDest.height);
 }
 
 TEST_F(ViewportTransformTest, doLayerSRCTransformationTest4){
     uint surfaceOriginalWidth = 100;
     uint surfaceOriginalHeight = 100;
-    Rectangle targetSurfaceSrc(0,0,100,100);
-    Rectangle targetSurfaceDest(0,0,100,100);
-    Rectangle layerSRC(25,25,50,50);
+    FloatRectangle targetSurfaceSrc = FloatRectangle(0,0,100,100);
+    FloatRectangle targetSurfaceDest = FloatRectangle(0,0,100,100);
+    FloatRectangle layerSRC = FloatRectangle(25,25,50,50);
 
     ViewportTransform::applyLayerSource(layerSRC,targetSurfaceSrc,targetSurfaceDest);
     float* textureCoordinates = new float[4];
@@ -242,19 +241,19 @@ TEST_F(ViewportTransformTest, doLayerSRCTransformationTest4){
     ASSERT_NEAR(0.75,textureCoordinates[1],0.01);
     ASSERT_NEAR(0.25,textureCoordinates[2],0.01);
     ASSERT_NEAR(0.75,textureCoordinates[3],0.01);
-    ASSERT_EQ(0u, targetSurfaceDest.x);
-    ASSERT_EQ(50u, targetSurfaceDest.width);
-    ASSERT_EQ(0u, targetSurfaceDest.y);
-    ASSERT_EQ(50u, targetSurfaceDest.height);
+    ASSERT_EQ(0.0, targetSurfaceDest.x);
+    ASSERT_EQ(50.0, targetSurfaceDest.width);
+    ASSERT_EQ(0.0, targetSurfaceDest.y);
+    ASSERT_EQ(50.0, targetSurfaceDest.height);
 }
 
 TEST_F(ViewportTransformTest, doLayerSRCTransformationTest5){
     uint surfaceOriginalWidth = 10;
     uint surfaceOriginalHeight = 10;
-    Rectangle targetSurfaceSrc(0,0,10,10);
-    Rectangle targetSurfaceDest(30,30,10,10);
-    Rectangle layerSRC(20,20,20,20);
-    Rectangle layerDest(0,0,40,40);
+    FloatRectangle targetSurfaceSrc = FloatRectangle(0,0,10,10);
+    FloatRectangle targetSurfaceDest = FloatRectangle(30,30,10,10);
+    FloatRectangle layerSRC = FloatRectangle(20,20,20,20);
+    FloatRectangle layerDest = FloatRectangle(0,0,40,40);
 
     ViewportTransform::applyLayerSource(layerSRC,targetSurfaceSrc,targetSurfaceDest);
     ViewportTransform::applyLayerDestination(layerDest,layerSRC,targetSurfaceDest);
@@ -264,19 +263,19 @@ TEST_F(ViewportTransformTest, doLayerSRCTransformationTest5){
     ASSERT_NEAR(1.0,textureCoordinates[1],0.01);
     ASSERT_NEAR(0.0,textureCoordinates[2],0.01);
     ASSERT_NEAR(1.0,textureCoordinates[3],0.01);
-    ASSERT_EQ(20u, targetSurfaceDest.x);
-    ASSERT_EQ(20u, targetSurfaceDest.width);
-    ASSERT_EQ(20u, targetSurfaceDest.y);
-    ASSERT_EQ(20u, targetSurfaceDest.height);
+    ASSERT_EQ(20.0, targetSurfaceDest.x);
+    ASSERT_EQ(20.0, targetSurfaceDest.width);
+    ASSERT_EQ(20.0, targetSurfaceDest.y);
+    ASSERT_EQ(20.0, targetSurfaceDest.height);
 }
 
 TEST_F(ViewportTransformTest, doLayerDESTTransformationTest1){
     uint surfaceOriginalWidth = 10;
     uint surfaceOriginalHeight = 10;
-    Rectangle targetSurfaceSrc(0,0,10,10);
-    Rectangle targetSurfaceDest(0,0,100,100);
-    Rectangle layerSRC(0,0,100,100);
-    Rectangle layerDest(0,0,100,100);
+    FloatRectangle targetSurfaceSrc = FloatRectangle(0,0,10,10);
+    FloatRectangle targetSurfaceDest = FloatRectangle(0,0,100,100);
+    FloatRectangle layerSRC = FloatRectangle(0,0,100,100);
+    FloatRectangle layerDest = FloatRectangle(0,0,100,100);
 
     ViewportTransform::applyLayerDestination(layerDest,layerSRC,targetSurfaceDest);
     float* textureCoordinates = new float[4];
@@ -285,19 +284,19 @@ TEST_F(ViewportTransformTest, doLayerDESTTransformationTest1){
     ASSERT_NEAR(1.0,textureCoordinates[1],0.01);
     ASSERT_NEAR(0.0,textureCoordinates[2],0.01);
     ASSERT_NEAR(1.0,textureCoordinates[3],0.01);
-    ASSERT_EQ(0u, targetSurfaceDest.x);
-    ASSERT_EQ(100u, targetSurfaceDest.width);
-    ASSERT_EQ(0u, targetSurfaceDest.y);
-    ASSERT_EQ(100u, targetSurfaceDest.height);
+    ASSERT_EQ(0.0, targetSurfaceDest.x);
+    ASSERT_EQ(100.0, targetSurfaceDest.width);
+    ASSERT_EQ(0.0, targetSurfaceDest.y);
+    ASSERT_EQ(100.0, targetSurfaceDest.height);
 }
 
 TEST_F(ViewportTransformTest, doLayerDESTTransformationTest2){
     uint surfaceOriginalWidth = 100;
     uint surfaceOriginalHeight = 100;
-    Rectangle targetSurfaceSrc(0,0,100,100);
-    Rectangle targetSurfaceDest(0,0,100,100);
-    Rectangle layerSRC(0,0,100,100);
-    Rectangle layerDest(0,0,200,200);
+    FloatRectangle targetSurfaceSrc = FloatRectangle(0,0,100,100);
+    FloatRectangle targetSurfaceDest = FloatRectangle(0,0,100,100);
+    FloatRectangle layerSRC = FloatRectangle(0,0,100,100);
+    FloatRectangle layerDest = FloatRectangle(0,0,200,200);
 
     ViewportTransform::applyLayerDestination(layerDest,layerSRC,targetSurfaceDest);
     float* textureCoordinates = new float[4];
@@ -306,92 +305,89 @@ TEST_F(ViewportTransformTest, doLayerDESTTransformationTest2){
     ASSERT_NEAR(1.0,textureCoordinates[1],0.01);
     ASSERT_NEAR(0.0,textureCoordinates[2],0.01);
     ASSERT_NEAR(1.0,textureCoordinates[3],0.01);
-    ASSERT_EQ(0u, targetSurfaceDest.x);
-    ASSERT_EQ(200u, targetSurfaceDest.width);
-    ASSERT_EQ(0u, targetSurfaceDest.y);
-    ASSERT_EQ(200u, targetSurfaceDest.height);
+    ASSERT_EQ(0.0, targetSurfaceDest.x);
+    ASSERT_EQ(200.0, targetSurfaceDest.width);
+    ASSERT_EQ(0.0, targetSurfaceDest.y);
+    ASSERT_EQ(200.0, targetSurfaceDest.height);
 }
 
 TEST_F(ViewportTransformTest, doLayerDESTTransformationTest3){
     uint surfaceOriginalWidth = 100;
     uint surfaceOriginalHeight = 100;
-    Rectangle targetSurfaceSrc(0,0,100,100);
-    Rectangle targetSurfaceDest(0,0,100,100);
-    Rectangle layerSRC(0,0,100,100);
-    Rectangle layerDest(50,50,200,200);
+    FloatRectangle targetSurfaceSrc = FloatRectangle(0,0,100,100);
+    FloatRectangle targetSurfaceDest = FloatRectangle(0,0,100,100);
+    FloatRectangle layerSRC = FloatRectangle(0,0,100,100);
+    FloatRectangle layerDest = FloatRectangle(50,50,200,200);
 
     ViewportTransform::applyLayerDestination(layerDest,layerSRC,targetSurfaceDest);
     float* textureCoordinates = new float[4];
     ViewportTransform::transformRectangleToTextureCoordinates(targetSurfaceSrc, surfaceOriginalWidth, surfaceOriginalHeight, textureCoordinates);
     ASSERT_NEAR(0.0,textureCoordinates[0],0.01);
     ASSERT_NEAR(1.0,textureCoordinates[1],0.01);
-    ASSERT_EQ(50u, targetSurfaceDest.x);
-    ASSERT_EQ(200u, targetSurfaceDest.width);
+    ASSERT_EQ(50.0, targetSurfaceDest.x);
+    ASSERT_EQ(200.0, targetSurfaceDest.width);
     ASSERT_NEAR(0.0,textureCoordinates[2],0.01);
     ASSERT_NEAR(1.0,textureCoordinates[3],0.01);
-    ASSERT_EQ(50u, targetSurfaceDest.y);
-    ASSERT_EQ(200u, targetSurfaceDest.height);
+    ASSERT_EQ(50.0, targetSurfaceDest.y);
+    ASSERT_EQ(200.0, targetSurfaceDest.height);
 }
 
 TEST_F(ViewportTransformTest, doLayerDESTTransformationTest4){
     uint surfaceOriginalWidth = 50;
     uint surfaceOriginalHeight = 50;
-    Rectangle targetSurfaceSrc(0,0,50,50);
-    Rectangle targetSurfaceDest(50,50,50,50);
-    Rectangle layerSrc(50,50,100,100);
-    Rectangle layerDest(50,50,200,200);
+    FloatRectangle targetSurfaceSrc = FloatRectangle(0,0,50,50);
+    FloatRectangle targetSurfaceDest = FloatRectangle(50,50,50,50);
+    FloatRectangle layerSrc = FloatRectangle(50,50,100,100);
+    FloatRectangle layerDest = FloatRectangle(50,50,200,200);
 
     ViewportTransform::applyLayerDestination(layerDest,layerSrc,targetSurfaceDest);
     float* textureCoordinates = new float[4];
     ViewportTransform::transformRectangleToTextureCoordinates(targetSurfaceSrc, surfaceOriginalWidth, surfaceOriginalHeight, textureCoordinates);
     ASSERT_NEAR(0.0,textureCoordinates[0],0.01);
     ASSERT_NEAR(1.0,textureCoordinates[1],0.01);
-    ASSERT_EQ(150u, targetSurfaceDest.x);
-    ASSERT_EQ(100u, targetSurfaceDest.width);
+    ASSERT_EQ(150.0, targetSurfaceDest.x);
+    ASSERT_EQ(100.0, targetSurfaceDest.width);
     ASSERT_NEAR(0.0,textureCoordinates[2],0.01);
     ASSERT_NEAR(1.0,textureCoordinates[3],0.01);
-    ASSERT_EQ(150u, targetSurfaceDest.y);
-    ASSERT_EQ(100u, targetSurfaceDest.height);
+    ASSERT_EQ(150.0, targetSurfaceDest.y);
+    ASSERT_EQ(100.0, targetSurfaceDest.height);
 }
 
 TEST_F(ViewportTransformTest, completeExample1){
     int surfaceOriginalWidth =60;
     int surfaceOriginalHeight = 60;
-    Rectangle surfaceSRC(20,20,20,20);
-    Rectangle surfaceDEST(20,20,60,60);
-
-    Rectangle layerSRC(50,50,50,50);
-    Rectangle layerDest(0,0,200,200);
+    FloatRectangle targetSurfaceSrc = FloatRectangle(20,20,20,20);
+    FloatRectangle targetSurfaceDest = FloatRectangle(20,20,60,60);
 
-    Rectangle targetSurfaceSrc = surfaceSRC;
-    Rectangle targetSurfaceDest = surfaceDEST;
+    FloatRectangle layerSRC = FloatRectangle(50,50,50,50);
+    FloatRectangle layerDest = FloatRectangle(0,0,200,200);
 
     ViewportTransform::applyLayerSource(layerSRC,targetSurfaceSrc,targetSurfaceDest);
     float* textureCoordinates = new float[4];
     ViewportTransform::transformRectangleToTextureCoordinates(targetSurfaceSrc, surfaceOriginalWidth, surfaceOriginalHeight, textureCoordinates);
 
-    ASSERT_EQ(30u,targetSurfaceSrc.x);
-    ASSERT_EQ(10u,targetSurfaceSrc.width);
-    ASSERT_EQ(30u,targetSurfaceSrc.y);
-    ASSERT_EQ(10u,targetSurfaceSrc.height);
+    ASSERT_EQ(30.0,targetSurfaceSrc.x);
+    ASSERT_EQ(10.0,targetSurfaceSrc.width);
+    ASSERT_EQ(30.0,targetSurfaceSrc.y);
+    ASSERT_EQ(10.0,targetSurfaceSrc.height);
     ASSERT_NEAR(0.5,textureCoordinates[0],0.01);
     ASSERT_NEAR(0.66,textureCoordinates[1],0.01);
     ASSERT_NEAR(0.5,textureCoordinates[2],0.01);
     ASSERT_NEAR(0.66,textureCoordinates[3],0.01);
 
-    ASSERT_EQ(0u,targetSurfaceDest.x);
-    ASSERT_EQ(30u,targetSurfaceDest.width);
-    ASSERT_EQ(0u,targetSurfaceDest.y);
-    ASSERT_EQ(30u,targetSurfaceDest.height);
+    ASSERT_EQ(0.0,targetSurfaceDest.x);
+    ASSERT_EQ(30.0,targetSurfaceDest.width);
+    ASSERT_EQ(0.0,targetSurfaceDest.y);
+    ASSERT_EQ(30.0,targetSurfaceDest.height);
 
     ViewportTransform::applyLayerDestination(layerDest,layerSRC,targetSurfaceDest);
     ViewportTransform::transformRectangleToTextureCoordinates(targetSurfaceSrc, surfaceOriginalWidth, surfaceOriginalHeight, textureCoordinates);
-    ASSERT_EQ(120u,targetSurfaceDest.width);
-    ASSERT_EQ(0u,targetSurfaceDest.x);
+    ASSERT_EQ(120.0,targetSurfaceDest.width);
+    ASSERT_EQ(0.0,targetSurfaceDest.x);
     ASSERT_NEAR(0.5,textureCoordinates[0],0.01);
     ASSERT_NEAR(0.66,textureCoordinates[1],0.01);
-    ASSERT_EQ(120u,targetSurfaceDest.height);
-    ASSERT_EQ(0u,targetSurfaceDest.y);
+    ASSERT_EQ(120.0,targetSurfaceDest.height);
+    ASSERT_EQ(0.0,targetSurfaceDest.y);
     ASSERT_NEAR(0.5,textureCoordinates[2],0.01);
     ASSERT_NEAR(0.66,textureCoordinates[3],0.01);
 
@@ -400,26 +396,23 @@ TEST_F(ViewportTransformTest, completeExample1){
 TEST_F(ViewportTransformTest, completeExample2){
     int surfaceOriginalWidth =100;
     int surfaceOriginalHeight = 100;
-    Rectangle surfaceSRC(0,0,100,100);
-    Rectangle surfaceDEST(100,100,100,100);
-
-    Rectangle layerDest(0,0,200,200);
-    Rectangle layerSRC(100,100,100,100);
+    FloatRectangle targetSurfaceSrc = FloatRectangle(0,0,100,100);
+    FloatRectangle targetSurfaceDest = FloatRectangle(100,100,100,100);
 
-    Rectangle targetSurfaceSrc = surfaceSRC;
-    Rectangle targetSurfaceDest = surfaceDEST;
+    FloatRectangle layerDest = FloatRectangle(0,0,200,200);
+    FloatRectangle layerSRC = FloatRectangle(100,100,100,100);
 
     ViewportTransform::applyLayerSource(layerSRC,targetSurfaceSrc,targetSurfaceDest);
     ViewportTransform::applyLayerDestination(layerDest,layerSRC,targetSurfaceDest);
     float* textureCoordinates = new float[4];
     ViewportTransform::transformRectangleToTextureCoordinates(targetSurfaceSrc, surfaceOriginalWidth, surfaceOriginalHeight, textureCoordinates);
 
-    ASSERT_EQ(200u,targetSurfaceDest.width);
-    ASSERT_EQ(0u,targetSurfaceDest.x);
+    ASSERT_EQ(200.0,targetSurfaceDest.width);
+    ASSERT_EQ(0.0,targetSurfaceDest.x);
     ASSERT_NEAR(0.0,textureCoordinates[0],0.01);
     ASSERT_NEAR(1.0,textureCoordinates[1],0.01);
-    ASSERT_EQ(200u,targetSurfaceDest.height);
-    ASSERT_EQ(0u,targetSurfaceDest.y);
+    ASSERT_EQ(200.0,targetSurfaceDest.height);
+    ASSERT_EQ(0.0,targetSurfaceDest.y);
     ASSERT_NEAR(0.0,textureCoordinates[2],0.01);
     ASSERT_NEAR(1.0,textureCoordinates[3],0.01);
 }
@@ -427,54 +420,47 @@ TEST_F(ViewportTransformTest, completeExample2){
 TEST_F(ViewportTransformTest, completeExample3){
     int surfaceOriginalWidth =100;
     int surfaceOriginalHeight = 100;
-    Rectangle surfaceSRC(50,50,50,50);
-    Rectangle surfaceDEST(100,100,100,100);
+    FloatRectangle targetSurfaceSrc = FloatRectangle(50,50,50,50);
+    FloatRectangle targetSurfaceDest = FloatRectangle(100,100,100,100);
 
-    Rectangle layerDest(0,0,200,200);
-    Rectangle layerSRC(100,100,100,100);
-
-    Rectangle targetSurfaceSrc = surfaceSRC;
-    Rectangle targetSurfaceDest = surfaceDEST;
+    FloatRectangle layerDest = FloatRectangle(0,0,200,200);
+    FloatRectangle layerSRC = FloatRectangle(100,100,100,100);
 
     ViewportTransform::applyLayerSource(layerSRC,targetSurfaceSrc,targetSurfaceDest);
     ViewportTransform::applyLayerDestination(layerDest,layerSRC,targetSurfaceDest);
     float* textureCoordinates = new float[4];
     ViewportTransform::transformRectangleToTextureCoordinates(targetSurfaceSrc, surfaceOriginalWidth, surfaceOriginalHeight, textureCoordinates);
 
-    ASSERT_EQ(200u,targetSurfaceDest.width);
-    ASSERT_EQ(0u,targetSurfaceDest.x);
+    ASSERT_EQ(200.0,targetSurfaceDest.width);
+    ASSERT_EQ(0.0,targetSurfaceDest.x);
     ASSERT_NEAR(0.5,textureCoordinates[0],0.01);
     ASSERT_NEAR(1.0,textureCoordinates[1],0.01);
-    ASSERT_EQ(200u,targetSurfaceDest.height);
-    ASSERT_EQ(0u,targetSurfaceDest.y);
+    ASSERT_EQ(200.0,targetSurfaceDest.height);
+    ASSERT_EQ(0.0,targetSurfaceDest.y);
     ASSERT_NEAR(0.5,textureCoordinates[2],0.01);
     ASSERT_NEAR(1.0,textureCoordinates[3],0.01);
-    
 }
 
 TEST_F(ViewportTransformTest, completeExample4){
     int surfaceOriginalWidth =100;
     int surfaceOriginalHeight = 100;
-    Rectangle surfaceSRC(50,50,50,50);
-    Rectangle surfaceDEST(100,100,100,100);
-
-    Rectangle layerDest(50,50,200,200);
-    Rectangle layerSRC(100,100,100,100);
+    FloatRectangle targetSurfaceSrc = FloatRectangle(50,50,50,50);
+    FloatRectangle targetSurfaceDest = FloatRectangle(100,100,100,100);
 
-    Rectangle targetSurfaceSrc = surfaceSRC;
-    Rectangle targetSurfaceDest = surfaceDEST;
+    FloatRectangle layerDest = FloatRectangle(50,50,200,200);
+    FloatRectangle layerSRC = FloatRectangle(100,100,100,100);
 
     ViewportTransform::applyLayerSource(layerSRC,targetSurfaceSrc,targetSurfaceDest);
     ViewportTransform::applyLayerDestination(layerDest,layerSRC,targetSurfaceDest);
     float* textureCoordinates = new float[4];
     ViewportTransform::transformRectangleToTextureCoordinates(targetSurfaceSrc, surfaceOriginalWidth, surfaceOriginalHeight, textureCoordinates);
 
-    ASSERT_EQ(200u,targetSurfaceDest.width);
-    ASSERT_EQ(50u,targetSurfaceDest.x);
+    ASSERT_EQ(200.0,targetSurfaceDest.width);
+    ASSERT_EQ(50.0,targetSurfaceDest.x);
     ASSERT_NEAR(0.5,textureCoordinates[0],0.01);
     ASSERT_NEAR(1.0,textureCoordinates[1],0.01);
-    ASSERT_EQ(200u,targetSurfaceDest.height);
-    ASSERT_EQ(50u,targetSurfaceDest.y);
+    ASSERT_EQ(200.0,targetSurfaceDest.height);
+    ASSERT_EQ(50.0,targetSurfaceDest.y);
     ASSERT_NEAR(0.5,textureCoordinates[2],0.01);
     ASSERT_NEAR(1.0,textureCoordinates[3],0.01);
 }
@@ -483,26 +469,23 @@ TEST_F(ViewportTransformTest, completeExample5){
     int surfaceOriginalWidth =320;
     int surfaceOriginalHeight = 320;
 
-    Rectangle surfaceSRC(0,0,320,320);
-    Rectangle surfaceDEST(0,0,320,320);
+    FloatRectangle targetSurfaceSrc = FloatRectangle(0,0,320,320);
+    FloatRectangle targetSurfaceDest = FloatRectangle(0,0,320,320);
 
-    Rectangle layerSRC(100,100,1280,1280);
-    Rectangle layerDest(0,0,1280,1280);
-
-    Rectangle targetSurfaceSrc = surfaceSRC;
-    Rectangle targetSurfaceDest = surfaceDEST;
+    FloatRectangle layerSRC = FloatRectangle(100,100,1280,1280);
+    FloatRectangle layerDest = FloatRectangle(0,0,1280,1280);
 
     ViewportTransform::applyLayerSource(layerSRC,targetSurfaceSrc,targetSurfaceDest);
     ViewportTransform::applyLayerDestination(layerDest,layerSRC,targetSurfaceDest);
     float* textureCoordinates = new float[4];
     ViewportTransform::transformRectangleToTextureCoordinates(targetSurfaceSrc, surfaceOriginalWidth, surfaceOriginalHeight, textureCoordinates);
 
-    ASSERT_EQ(0u,targetSurfaceDest.x);
-    ASSERT_EQ(220u,targetSurfaceDest.width);
+    ASSERT_EQ(0.0,targetSurfaceDest.x);
+    ASSERT_EQ(220.0,targetSurfaceDest.width);
     ASSERT_NEAR(0.3125,textureCoordinates[0],0.01);
     ASSERT_NEAR(1.0,textureCoordinates[1],0.01);
-    ASSERT_EQ(0u,targetSurfaceDest.y);
-    ASSERT_EQ(220u,targetSurfaceDest.height);
+    ASSERT_EQ(0.0,targetSurfaceDest.y);
+    ASSERT_EQ(220.0,targetSurfaceDest.height);
     ASSERT_NEAR(0.3125,textureCoordinates[2],0.01);
     ASSERT_NEAR(1.0,textureCoordinates[3],0.01);
 }
@@ -510,29 +493,26 @@ TEST_F(ViewportTransformTest, completeExample5){
 TEST_F(ViewportTransformTest, completeExample6){
     int surfaceOriginalWidth =320;
     int surfaceOriginalHeight =320;
-    Rectangle surfaceSRC(0,0,320,320);
-    Rectangle surfaceDEST(320,320,320,320);
-
-    Rectangle layerSRC(100,100,1280,1280);
-    Rectangle layerDest(0,0,1280,1280);
+    FloatRectangle targetSurfaceSrc = FloatRectangle(0,0,320,320);
+    FloatRectangle targetSurfaceDest = FloatRectangle(320,320,320,320);
 
-    Rectangle targetSurfaceSrc = surfaceSRC;
-    Rectangle targetSurfaceDest = surfaceDEST;
+    FloatRectangle layerSRC = FloatRectangle(100,100,1280,1280);
+    FloatRectangle layerDest = FloatRectangle(0,0,1280,1280);
 
     ViewportTransform::applyLayerSource(layerSRC,targetSurfaceSrc,targetSurfaceDest);
     ViewportTransform::applyLayerDestination(layerDest,layerSRC,targetSurfaceDest);
 
     float* textureCoordinates = new float[4];
     ViewportTransform::transformRectangleToTextureCoordinates(targetSurfaceSrc, surfaceOriginalWidth, surfaceOriginalHeight, textureCoordinates);
-    ASSERT_EQ(220u,targetSurfaceDest.x);
-    ASSERT_EQ(320u,targetSurfaceDest.width);
-    ASSERT_EQ(220u,targetSurfaceDest.y);
-    ASSERT_EQ(320u,targetSurfaceDest.height);
+    ASSERT_EQ(220.0,targetSurfaceDest.x);
+    ASSERT_EQ(320.0,targetSurfaceDest.width);
+    ASSERT_EQ(220.0,targetSurfaceDest.y);
+    ASSERT_EQ(320.0,targetSurfaceDest.height);
 
-    ASSERT_EQ(0u,targetSurfaceSrc.x);
-    ASSERT_EQ(320u,targetSurfaceSrc.width);
-    ASSERT_EQ(0u,targetSurfaceSrc.y);
-    ASSERT_EQ(320u,targetSurfaceSrc.height);
+    ASSERT_EQ(0.0,targetSurfaceSrc.x);
+    ASSERT_EQ(320.0,targetSurfaceSrc.width);
+    ASSERT_EQ(0.0,targetSurfaceSrc.y);
+    ASSERT_EQ(320.0,targetSurfaceSrc.height);
 
     ASSERT_NEAR(0.0,textureCoordinates[0],0.01);
     ASSERT_NEAR(1.0,textureCoordinates[1],0.01);
@@ -544,27 +524,24 @@ TEST_F(ViewportTransformTest, completeExample6){
 TEST_F(ViewportTransformTest, completeExample7){
     int surfaceOriginalWidth =320;
     int surfaceOriginalHeight =240;
-    Rectangle surfaceSRC(0,0,320,240);
-    Rectangle surfaceDEST(0,0,320,240);
+    FloatRectangle targetSurfaceSrc = FloatRectangle(0,0,320,240);
+    FloatRectangle targetSurfaceDest = FloatRectangle(0,0,320,240);
 
-    Rectangle layerSRC(100,0,80,240);
-    Rectangle layerDest(100,0,640,480);
-
-    Rectangle targetSurfaceSrc = surfaceSRC;
-    Rectangle targetSurfaceDest = surfaceDEST;
+    FloatRectangle layerSRC = FloatRectangle(100,0,80,240);
+    FloatRectangle layerDest = FloatRectangle(100,0,640,480);
 
     ViewportTransform::applyLayerSource(layerSRC,targetSurfaceSrc,targetSurfaceDest);
     ViewportTransform::applyLayerDestination(layerDest,layerSRC,targetSurfaceDest);
 
-    ASSERT_EQ(100u,targetSurfaceSrc.x);
-    ASSERT_EQ(80u,targetSurfaceSrc.width);
-    ASSERT_EQ(0u,targetSurfaceSrc.y);
-    ASSERT_EQ(240u,targetSurfaceSrc.height);
+    ASSERT_EQ(100.0,targetSurfaceSrc.x);
+    ASSERT_EQ(80.0,targetSurfaceSrc.width);
+    ASSERT_EQ(0.0,targetSurfaceSrc.y);
+    ASSERT_EQ(240.0,targetSurfaceSrc.height);
 
-    ASSERT_EQ(100u,targetSurfaceDest.x);
-    ASSERT_EQ(640u,targetSurfaceDest.width);
-    ASSERT_EQ(0u,targetSurfaceDest.y);
-    ASSERT_EQ(480u,targetSurfaceDest.height);
+    ASSERT_EQ(100.0,targetSurfaceDest.x);
+    ASSERT_EQ(640.0,targetSurfaceDest.width);
+    ASSERT_EQ(0.0,targetSurfaceDest.y);
+    ASSERT_EQ(480.0,targetSurfaceDest.height);
 
     float* textureCoordinates = new float[4];
     ViewportTransform::transformRectangleToTextureCoordinates(targetSurfaceSrc, surfaceOriginalWidth, surfaceOriginalHeight, textureCoordinates);
@@ -577,27 +554,24 @@ TEST_F(ViewportTransformTest, completeExample7){
 TEST_F(ViewportTransformTest, completeExample8){
     int surfaceOriginalWidth =320;
     int surfaceOriginalHeight =240;
-    Rectangle surfaceSRC(1,0,320,240);
-    Rectangle surfaceDEST(0,0,320,240);
-
-    Rectangle layerSRC(0,0,1280,480);
-    Rectangle layerDest(0,0,1280,480);
+    FloatRectangle targetSurfaceSrc = FloatRectangle(1,0,320,240);
+    FloatRectangle targetSurfaceDest = FloatRectangle(0,0,320,240);
 
-    Rectangle targetSurfaceSrc = surfaceSRC;
-    Rectangle targetSurfaceDest = surfaceDEST;
+    FloatRectangle layerSRC = FloatRectangle(0,0,1280,480);
+    FloatRectangle layerDest = FloatRectangle(0,0,1280,480);
 
     ViewportTransform::applyLayerSource(layerSRC,targetSurfaceSrc,targetSurfaceDest);
     ViewportTransform::applyLayerDestination(layerDest,layerSRC,targetSurfaceDest);
 
-    ASSERT_EQ(1u,targetSurfaceSrc.x);
-    ASSERT_EQ(320u,targetSurfaceSrc.width);
-    ASSERT_EQ(0u,targetSurfaceSrc.y);
-    ASSERT_EQ(240u,targetSurfaceSrc.height);
+    ASSERT_EQ(1.0,targetSurfaceSrc.x);
+    ASSERT_EQ(320.0,targetSurfaceSrc.width);
+    ASSERT_EQ(0.0,targetSurfaceSrc.y);
+    ASSERT_EQ(240.0,targetSurfaceSrc.height);
 
-    ASSERT_EQ(0u,targetSurfaceDest.x);
-    ASSERT_EQ(320u,targetSurfaceDest.width);
-    ASSERT_EQ(0u,targetSurfaceDest.y);
-    ASSERT_EQ(240u,targetSurfaceDest.height);
+    ASSERT_EQ(0.0,targetSurfaceDest.x);
+    ASSERT_EQ(320.0,targetSurfaceDest.width);
+    ASSERT_EQ(0.0,targetSurfaceDest.y);
+    ASSERT_EQ(240.0,targetSurfaceDest.height);
 
     float* textureCoordinates = new float[4];
     ViewportTransform::transformRectangleToTextureCoordinates(targetSurfaceSrc, surfaceOriginalWidth, surfaceOriginalHeight, textureCoordinates);
@@ -610,22 +584,20 @@ TEST_F(ViewportTransformTest, completeExample8){
 TEST_F(ViewportTransformTest, layersourceZoomOnTwoSurfaces){
     int surfaceOriginalWidth = 800;
     int surfaceOriginalHeight = 480;
-    Rectangle layerSRC(100, 0, 600, 480);
-    Rectangle layerDest(0, 0, 800, 480);
+    FloatRectangle layerSRC = FloatRectangle(100, 0, 600, 480);
+    FloatRectangle layerDest = FloatRectangle(0, 0, 800, 480);
 
-    Rectangle surface1SRC(0, 0, 800, 480);
-    Rectangle surface1DEST(0, 0, 400, 480);
-    Rectangle targetSurface1Src = surface1SRC;
-    Rectangle targetSurface1Dest = surface1DEST;
+    FloatRectangle targetSurface1Src = FloatRectangle(0, 0, 800, 480);
+    FloatRectangle targetSurface1Dest = FloatRectangle(0, 0, 400, 480);
 
     ViewportTransform::applyLayerSource(layerSRC,targetSurface1Src,targetSurface1Dest);
     ViewportTransform::applyLayerDestination(layerDest,layerSRC,targetSurface1Dest);
 
-    ASSERT_EQ(200u, targetSurface1Src.x);
-    ASSERT_EQ(600u, targetSurface1Src.width);
+    ASSERT_EQ(200.0, targetSurface1Src.x);
+    ASSERT_EQ(600.0, targetSurface1Src.width);
 
-    ASSERT_EQ(0u,targetSurface1Dest.x);
-    ASSERT_EQ(400u,targetSurface1Dest.width);
+    ASSERT_EQ(0.0,targetSurface1Dest.x);
+    ASSERT_EQ(400.0,targetSurface1Dest.width);
 
     float* textureCoordinates = new float[4];
     ViewportTransform::transformRectangleToTextureCoordinates(targetSurface1Src, surfaceOriginalWidth, surfaceOriginalHeight, textureCoordinates);
@@ -634,19 +606,17 @@ TEST_F(ViewportTransformTest, layersourceZoomOnTwoSurfaces){
     ASSERT_NEAR(0.0,textureCoordinates[2],0.01);
     ASSERT_NEAR(1.0,textureCoordinates[3],0.01);
 
-    Rectangle surface2SRC(0, 0, 800, 480);
-    Rectangle surface2DEST(400, 0, 400, 480);
-    Rectangle targetSurface2Src = surface2SRC;
-    Rectangle targetSurface2Dest = surface2DEST;
+    FloatRectangle targetSurface2Src = FloatRectangle(0, 0, 800, 480);
+    FloatRectangle targetSurface2Dest = FloatRectangle(400, 0, 400, 480);
 
     ViewportTransform::applyLayerSource(layerSRC,targetSurface2Src,targetSurface2Dest);
     ViewportTransform::applyLayerDestination(layerDest,layerSRC,targetSurface2Dest);
 
-    ASSERT_EQ(0u, targetSurface2Src.x);
-    ASSERT_EQ(600u, targetSurface2Src.width);
+    ASSERT_EQ(0.0, targetSurface2Src.x);
+    ASSERT_EQ(600.0, targetSurface2Src.width);
 
-    ASSERT_EQ(400u,targetSurface2Dest.x);
-    ASSERT_EQ(400u,targetSurface2Dest.width);
+    ASSERT_EQ(400.0,targetSurface2Dest.x);
+    ASSERT_EQ(400.0,targetSurface2Dest.width);
 
     float* textureCoordinates2 = new float[4];
     ViewportTransform::transformRectangleToTextureCoordinates(targetSurface2Src, surfaceOriginalWidth, surfaceOriginalHeight, textureCoordinates2);

diff --git a/LayerManagerService/include/Rectangle.h b/LayerManagerService/include/Rectangle.h
index 359f4dd..589fff3 100644 (file)
--- a/LayerManagerService/include/Rectangle.h
+++ b/LayerManagerService/include/Rectangle.h
@@ -52,4 +52,37 @@ public:
     }
 };
 
+class FloatRectangle
+{
+public:
+    FloatRectangle()
+    : x(0.0f)
+    , y(0.0f)
+    , width(0.0f)
+    , height(0.0f)
+    {
+    }
+
+    FloatRectangle(float x, float y, float width, float height)
+    : x(x)
+    , y(y)
+    , width(width)
+    , height(height)
+    {
+    }
+
+    FloatRectangle(const Rectangle& rhs)
+    : x(rhs.x)
+    , y(rhs.y)
+    , width(rhs.width)
+    , height(rhs.height)
+    {
+    }
+
+    float x;
+    float y;
+    float width;
+    float height;
+};
+
 #endif /* _RECTANGLE_H_ */