INTEGRATION: CWS canvas02 (1.1.2); FILE ADDED

2005/10/24 16:40:25 thb 1.1.2.9: #i48939# Immediately exiting when trying to render an empty area.
2005/10/17 14:11:23 mbu 1.1.2.8: solved issue with drawRectangularArea()
2005/10/11 15:41:19 thb 1.1.2.7: #i54170# Corrected license headers
2005/10/07 23:05:05 thb 1.1.2.6: #i48939# Unified formatting; improved constness; avoided a few copy constructions; pruned debug code; removed empty destructors; moved end iterator queries out of the loops
2005/10/07 13:12:20 mbu 1.1.2.5: added comment
2005/10/07 08:00:09 mbu 1.1.2.4: drawRectangularArea() did not work as expected, fixed.
2005/10/04 15:34:56 mbu 1.1.2.3: now using correct rounding mode
2005/09/29 14:19:36 mbu 1.1.2.2: pagemanager validates hardware surfaces now and handles this case properly
2005/09/29 09:41:03 mbu 1.1.2.1: surfaceproxy now has completely redesigned strategy, does no longer depend on amount of available videomemory

1 files changed, 492 insertions, 0 deletions

diff --git a/canvas/source/tools/surface.cxx b/canvas/source/tools/surface.cxx
new file mode 100644
index 000000000000..85caf11f4726
--- /dev/null
+++ b/canvas/source/tools/surface.cxx
@@ -0,0 +1,492 @@
+/*************************************************************************
+ *
+ *  OpenOffice.org - a multi-platform office productivity suite
+ *
+ *  $RCSfile: surface.cxx,v $
+ *
+ *  $Revision: 1.2 $
+ *
+ *  last change: $Author: kz $ $Date: 2005-11-02 12:55:26 $
+ *
+ *  The Contents of this file are made available subject to
+ *  the terms of GNU Lesser General Public License Version 2.1.
+ *
+ *
+ *    GNU Lesser General Public License Version 2.1
+ *    =============================================
+ *    Copyright 2005 by Sun Microsystems, Inc.
+ *    901 San Antonio Road, Palo Alto, CA 94303, USA
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License version 2.1, as published by the Free Software Foundation.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ *
+ *    You should have received a copy of the GNU Lesser General Public
+ *    License along with this library; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
+ *    MA  02111-1307  USA
+ *
+ ************************************************************************/
+
+#include "surface.hxx"
+#include <basegfx/polygon/b2dpolygonclipper.hxx>
+#include <comphelper/scopeguard.hxx>
+#include <boost/bind.hpp>
+
+namespace canvas
+{
+
+    //////////////////////////////////////////////////////////////////////////////////
+    // Surface::Surface
+    //////////////////////////////////////////////////////////////////////////////////
+
+    Surface::Surface( const PageManagerSharedPtr&  rPageManager,
+                      const IColorBufferSharedPtr& rColorBuffer,
+                      const ::basegfx::B2IPoint&   rPos,
+                      const ::basegfx::B2ISize&    rSize ) :
+        mpColorBuffer(rColorBuffer),
+        mpPageManager(rPageManager),
+        mpFragment(),
+        maSourceOffset(rPos),
+        maSize(rSize),
+        mbIsDirty(true)
+    {
+    }
+
+    //////////////////////////////////////////////////////////////////////////////////
+    // Surface::~Surface
+    //////////////////////////////////////////////////////////////////////////////////
+
+    Surface::~Surface()
+    {
+        if(mpFragment)
+            mpPageManager->free(mpFragment);
+    }
+
+    //////////////////////////////////////////////////////////////////////////////////
+    // Surface::getUVCoords
+    //////////////////////////////////////////////////////////////////////////////////
+
+    void Surface::setColorBufferDirty()
+    {
+        mbIsDirty=true;
+    }
+
+    //////////////////////////////////////////////////////////////////////////////////
+    // Surface::getUVCoords
+    //////////////////////////////////////////////////////////////////////////////////
+
+    basegfx::B2DRectangle Surface::getUVCoords() const
+    {
+        ::basegfx::B2ISize aPageSize(mpPageManager->getPageSize());
+        ::basegfx::B2IPoint aDestOffset(mpFragment->getPos());
+
+        const double pw( aPageSize.getX() );
+        const double ph( aPageSize.getY() );
+        const double ox( aDestOffset.getX() );
+        const double oy( aDestOffset.getY() );
+        const double sx( maSize.getX() );
+        const double sy( maSize.getY() );
+
+        return ::basegfx::B2DRectangle( ox/pw,
+                                        oy/ph,
+                                        (ox+sx)/pw,
+                                        (oy+sy)/ph );
+    }
+
+    //////////////////////////////////////////////////////////////////////////////////
+    // Surface::getUVCoords
+    //////////////////////////////////////////////////////////////////////////////////
+
+    basegfx::B2DRectangle Surface::getUVCoords( const ::basegfx::B2IPoint& rPos,
+                                                const ::basegfx::B2ISize&  rSize ) const
+    {
+        ::basegfx::B2ISize aPageSize(mpPageManager->getPageSize());
+
+        const double pw( aPageSize.getX() );
+        const double ph( aPageSize.getY() );
+        const double ox( rPos.getX() );
+        const double oy( rPos.getY() );
+        const double sx( rSize.getX() );
+        const double sy( rSize.getY() );
+
+        return ::basegfx::B2DRectangle( ox/pw,
+                                        oy/ph,
+                                        (ox+sx)/pw,
+                                        (oy+sy)/ph );
+    }
+
+    //////////////////////////////////////////////////////////////////////////////////
+    // Surface::draw
+    //////////////////////////////////////////////////////////////////////////////////
+
+    bool Surface::draw( double                          fAlpha,
+                        const ::basegfx::B2DPoint&      rPos,
+                        const ::basegfx::B2DHomMatrix&  rTransform )
+    {
+        IRenderModuleSharedPtr pRenderModule(mpPageManager->getRenderModule());
+
+        RenderModuleGuard aGuard( pRenderModule );
+
+        prepareRendering();
+
+        // convert size to normalized device coordinates
+        const ::basegfx::B2DRectangle& rUV( getUVCoords() );
+
+        const double u1(rUV.getMinX());
+        const double v1(rUV.getMinY());
+        const double u2(rUV.getMaxX());
+        const double v2(rUV.getMaxY());
+
+        // concat transforms
+        // 1) offset of surface subarea
+        // 2) surface transform
+        // 3) translation to output position [rPos]
+        // 4) scale to normalized device coordinates
+        // 5) flip y-axis
+        // 6) translate to account for viewport transform
+        ::basegfx::B2DHomMatrix aTransform;
+        aTransform.translate(maSourceOffset.getX(),
+                             maSourceOffset.getY());
+        aTransform = aTransform * rTransform;
+        aTransform.translate(::basegfx::fround(rPos.getX()),
+                             ::basegfx::fround(rPos.getY()));
+
+        /*
+            ######################################
+            ######################################
+            ######################################
+
+                           Y
+                           ^+1
+                           |
+                   2       |       3
+                     x------------x
+                     |     |      |
+                      |    |      |
+               ------|-----O------|------>X
+               -1    |     |      |     +1
+                     |     |      |
+                     x------------x
+                    1      |       0
+                            |
+                           |-1
+
+            ######################################
+            ######################################
+            ######################################
+        */
+
+        const ::basegfx::B2DPoint& p0(aTransform * ::basegfx::B2DPoint(maSize.getX(),maSize.getY()));
+        const ::basegfx::B2DPoint& p1(aTransform * ::basegfx::B2DPoint(0.0,maSize.getY()));
+        const ::basegfx::B2DPoint& p2(aTransform * ::basegfx::B2DPoint(0.0,0.0));
+        const ::basegfx::B2DPoint& p3(aTransform * ::basegfx::B2DPoint(maSize.getX(),0.0));
+
+        canvas::Vertex vertex;
+        vertex.r = 1.0f;
+        vertex.g = 1.0f;
+        vertex.b = 1.0f;
+        vertex.a = static_cast<float>(fAlpha);
+        vertex.z = 0.0f;
+
+        {
+            pRenderModule->beginPrimitive( canvas::IRenderModule::PRIMITIVE_TYPE_QUAD );
+
+            // issue an endPrimitive() when leaving the scope
+            const ::comphelper::ScopeGuard aGuard(
+                boost::bind( &::canvas::IRenderModule::endPrimitive,
+                             ::boost::ref(pRenderModule) ) );
+
+            vertex.u=static_cast<float>(u2); vertex.v=static_cast<float>(v2);
+            vertex.x=static_cast<float>(p0.getX()); vertex.y=static_cast<float>(p0.getY());
+            pRenderModule->pushVertex(vertex);
+
+            vertex.u=static_cast<float>(u1); vertex.v=static_cast<float>(v2);
+            vertex.x=static_cast<float>(p1.getX()); vertex.y=static_cast<float>(p1.getY());
+            pRenderModule->pushVertex(vertex);
+
+            vertex.u=static_cast<float>(u1); vertex.v=static_cast<float>(v1);
+            vertex.x=static_cast<float>(p2.getX()); vertex.y=static_cast<float>(p2.getY());
+            pRenderModule->pushVertex(vertex);
+
+            vertex.u=static_cast<float>(u2); vertex.v=static_cast<float>(v1);
+            vertex.x=static_cast<float>(p3.getX()); vertex.y=static_cast<float>(p3.getY());
+            pRenderModule->pushVertex(vertex);
+        }
+
+        return !(pRenderModule->isError());
+    }
+
+    //////////////////////////////////////////////////////////////////////////////////
+    // Surface::drawRectangularArea
+    //////////////////////////////////////////////////////////////////////////////////
+
+    bool Surface::drawRectangularArea(
+                        double                         fAlpha,
+                        const ::basegfx::B2DPoint&     rPos,
+                        const ::basegfx::B2DRectangle& rArea,
+                        const ::basegfx::B2DHomMatrix& rTransform )
+    {
+        if( rArea.isEmpty() )
+            return true; // immediate exit for empty area
+
+        IRenderModuleSharedPtr pRenderModule(mpPageManager->getRenderModule());
+
+        RenderModuleGuard aGuard( pRenderModule );
+
+        prepareRendering();
+
+        // these positions are relative to the texture
+        ::basegfx::B2IPoint aPos1(
+            ::basegfx::fround(rArea.getMinimum().getX()),
+            ::basegfx::fround(rArea.getMinimum().getY()));
+        ::basegfx::B2IPoint aPos2(
+            ::basegfx::fround(rArea.getMaximum().getX()),
+            ::basegfx::fround(rArea.getMaximum().getY()) );
+
+        // clip the positions to the area this surface covers
+        aPos1.setX(::std::max(aPos1.getX(),maSourceOffset.getX()));
+        aPos1.setY(::std::max(aPos1.getY(),maSourceOffset.getY()));
+        aPos2.setX(::std::min(aPos2.getX(),maSourceOffset.getX()+maSize.getX()));
+        aPos2.setY(::std::min(aPos2.getY(),maSourceOffset.getY()+maSize.getY()));
+
+        // if the resulting area is empty, return immediately
+        ::basegfx::B2IVector aSize(aPos2 - aPos1);
+        if(aSize.getX() <= 0 || aSize.getY() <= 0)
+            return true;
+
+        ::basegfx::B2IPoint aDestOffset(mpFragment->getPos());
+
+        // convert size to normalized device coordinates
+        const ::basegfx::B2DRectangle& rUV(
+            getUVCoords(aPos1 - maSourceOffset + aDestOffset,
+                        aSize) );
+        const double u1(rUV.getMinX());
+        const double v1(rUV.getMinY());
+        const double u2(rUV.getMaxX());
+        const double v2(rUV.getMaxY());
+
+        // concatenate transforms
+        // 1) offset of surface subarea
+        // 2) surface transform
+        // 3) translation to output position [rPos]
+        ::basegfx::B2DHomMatrix aTransform;
+        aTransform.translate(aPos1.getX(),aPos1.getY());
+        aTransform = aTransform * rTransform;
+        aTransform.translate(::basegfx::fround(rPos.getX()),
+                             ::basegfx::fround(rPos.getY()));
+
+
+        /*
+            ######################################
+            ######################################
+            ######################################
+
+                           Y
+                           ^+1
+                           |
+                   2       |       3
+                     x------------x
+                     |     |      |
+                      |    |      |
+               ------|-----O------|------>X
+               -1    |     |      |     +1
+                     |     |      |
+                     x------------x
+                    1      |       0
+                            |
+                           |-1
+
+            ######################################
+            ######################################
+            ######################################
+        */
+
+        const ::basegfx::B2DPoint& p0(aTransform * ::basegfx::B2DPoint(aSize.getX(),aSize.getY()));
+        const ::basegfx::B2DPoint& p1(aTransform * ::basegfx::B2DPoint(0.0,         aSize.getY()));
+        const ::basegfx::B2DPoint& p2(aTransform * ::basegfx::B2DPoint(0.0,         0.0));
+        const ::basegfx::B2DPoint& p3(aTransform * ::basegfx::B2DPoint(aSize.getX(),0.0));
+
+        canvas::Vertex vertex;
+        vertex.r = 1.0f;
+        vertex.g = 1.0f;
+        vertex.b = 1.0f;
+        vertex.a = static_cast<float>(fAlpha);
+        vertex.z = 0.0f;
+
+        {
+            pRenderModule->beginPrimitive( canvas::IRenderModule::PRIMITIVE_TYPE_QUAD );
+
+            // issue an endPrimitive() when leaving the scope
+            const ::comphelper::ScopeGuard aGuard(
+                boost::bind( &::canvas::IRenderModule::endPrimitive,
+                             ::boost::ref(pRenderModule) ) );
+
+            vertex.u=static_cast<float>(u2); vertex.v=static_cast<float>(v2);
+            vertex.x=static_cast<float>(p0.getX()); vertex.y=static_cast<float>(p0.getY());
+            pRenderModule->pushVertex(vertex);
+
+            vertex.u=static_cast<float>(u1); vertex.v=static_cast<float>(v2);
+            vertex.x=static_cast<float>(p1.getX()); vertex.y=static_cast<float>(p1.getY());
+            pRenderModule->pushVertex(vertex);
+
+            vertex.u=static_cast<float>(u1); vertex.v=static_cast<float>(v1);
+            vertex.x=static_cast<float>(p2.getX()); vertex.y=static_cast<float>(p2.getY());
+            pRenderModule->pushVertex(vertex);
+
+            vertex.u=static_cast<float>(u2); vertex.v=static_cast<float>(v1);
+            vertex.x=static_cast<float>(p3.getX()); vertex.y=static_cast<float>(p3.getY());
+            pRenderModule->pushVertex(vertex);
+        }
+
+        return !(pRenderModule->isError());
+    }
+
+    //////////////////////////////////////////////////////////////////////////////////
+    // Surface::drawWithClip
+    //////////////////////////////////////////////////////////////////////////////////
+
+    bool Surface::drawWithClip( double                          fAlpha,
+                                const ::basegfx::B2DPoint&      rPos,
+                                const ::basegfx::B2DPolygon&    rClipPoly,
+                                const ::basegfx::B2DHomMatrix&  rTransform )
+    {
+        IRenderModuleSharedPtr pRenderModule(mpPageManager->getRenderModule());
+
+        RenderModuleGuard aGuard( pRenderModule );
+
+        prepareRendering();
+
+        // untransformed surface rectangle, relative to the whole
+        // image (note: this surface might actually only be a tile of
+        // the whole image, with non-zero maSourceOffset)
+        const double x1(maSourceOffset.getX());
+        const double y1(maSourceOffset.getY());
+        const double w(maSize.getX());
+        const double h(maSize.getY());
+        const double x2(x1+w);
+        const double y2(y1+h);
+        const ::basegfx::B2DRectangle aSurfaceClipRect(x1,y1,x2,y2);
+
+        // concatenate transforms
+        // we use 'fround' here to avoid rounding errors. the vertices will
+        // be transformed by the overall transform and uv coordinates will
+        // be calculated from the result, and this is why we need to use
+        // integer coordinates here...
+        ::basegfx::B2DHomMatrix aTransform;
+        aTransform = aTransform * rTransform;
+        aTransform.translate(::basegfx::fround(rPos.getX()),
+                             ::basegfx::fround(rPos.getY()));
+
+        /*
+            ######################################
+            ######################################
+            ######################################
+
+                           Y
+                           ^+1
+                           |
+                   2       |       3
+                     x------------x
+                     |     |      |
+                      |    |      |
+               ------|-----O------|------>X
+               -1    |     |      |     +1
+                     |     |      |
+                     x------------x
+                    1      |       0
+                            |
+                           |-1
+
+            ######################################
+            ######################################
+            ######################################
+        */
+
+        // uv coordinates that map the surface rectangle
+        // to the destination rectangle.
+        const ::basegfx::B2DRectangle& rUV( getUVCoords() );
+
+        basegfx::B2DPolygon rTriangleList(basegfx::tools::clipTriangleListOnRange(rClipPoly,
+                                                                                  aSurfaceClipRect));
+
+        // Push vertices to backend renderer
+        if(const sal_uInt32 nVertexCount = rTriangleList.count())
+        {
+            canvas::Vertex vertex;
+            vertex.r = 1.0f;
+            vertex.g = 1.0f;
+            vertex.b = 1.0f;
+            vertex.a = static_cast<float>(fAlpha);
+            vertex.z = 0.0f;
+
+#if defined(TRIANGLE_LOG) && defined(DBG_UTIL)
+            OSL_TRACE( "Surface::draw(): numvertices %d numtriangles %d\n",
+                        nVertexCount,
+                        nVertexCount/3 );
+#endif
+
+            pRenderModule->beginPrimitive( canvas::IRenderModule::PRIMITIVE_TYPE_TRIANGLE );
+
+            // issue an endPrimitive() when leaving the scope
+            const ::comphelper::ScopeGuard aGuard(
+                boost::bind( &::canvas::IRenderModule::endPrimitive,
+                                ::boost::ref(pRenderModule) ) );
+
+            for(sal_uInt32 nIndex=0; nIndex<nVertexCount; ++nIndex)
+            {
+                const basegfx::B2DPoint &aPoint = rTriangleList.getB2DPoint(nIndex);
+                basegfx::B2DPoint aTransformedPoint(aTransform * aPoint);
+                const double tu(((aPoint.getX()-aSurfaceClipRect.getMinX())*rUV.getWidth()/w)+rUV.getMinX());
+                const double tv(((aPoint.getY()-aSurfaceClipRect.getMinY())*rUV.getHeight()/h)+rUV.getMinY());
+                vertex.u=static_cast<float>(tu);
+                vertex.v=static_cast<float>(tv);
+                vertex.x=static_cast<float>(aTransformedPoint.getX());
+                vertex.y=static_cast<float>(aTransformedPoint.getY());
+                pRenderModule->pushVertex(vertex);
+            }
+        }
+
+        return !(pRenderModule->isError());
+    }
+
+    //////////////////////////////////////////////////////////////////////////////////
+    // Surface::prepareRendering
+    //////////////////////////////////////////////////////////////////////////////////
+
+    void Surface::prepareRendering()
+    {
+        mpPageManager->validatePages();
+
+        // clients requested to draw from this surface, therefore one
+        // of the above implemented concrete rendering operations
+        // was triggered. we therefore need to ask the pagemanager
+        // to allocate some space for the fragment we're dedicated to.
+        if(!(mpFragment))
+        {
+            mpFragment = mpPageManager->allocateSpace(maSize);
+            mpFragment->setColorBuffer(mpColorBuffer);
+            mpFragment->setSourceOffset(maSourceOffset);
+        }
+
+        // now we need to 'select' the fragment, which will in turn
+        // pull informations from the image on demand.
+        // in case this fragment is still not located on any of the
+        // available pages ['naked'], we force the page manager to
+        // do it now, no way to defer this any longer...
+        if(!(mpFragment->select(mbIsDirty)))
+            mpPageManager->nakedFragment(mpFragment);
+
+        mbIsDirty=false;
+    }
+
+    //////////////////////////////////////////////////////////////////////////////////
+    // End of file
+    //////////////////////////////////////////////////////////////////////////////////
+}
+