summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rwxr-xr-x[-rw-r--r--]canvas/inc/canvas/canvastools.hxx13
-rwxr-xr-xcanvas/source/directx/dx_canvashelper_texturefill.cxx194
-rwxr-xr-xcanvas/source/directx/dx_impltools.cxx2
-rwxr-xr-x[-rw-r--r--]canvas/source/tools/canvastools.cxx48
-rwxr-xr-x[-rw-r--r--]canvas/source/vcl/canvashelper_texturefill.cxx75
5 files changed, 183 insertions, 149 deletions
diff --git a/canvas/inc/canvas/canvastools.hxx b/canvas/inc/canvas/canvastools.hxx
index 345bcd9187ae..cada66cb9957 100644..100755
--- a/canvas/inc/canvas/canvastools.hxx
+++ b/canvas/inc/canvas/canvastools.hxx
@@ -69,6 +69,7 @@ namespace com { namespace sun { namespace star { namespace rendering
struct ViewState;
struct IntegerBitmapLayout;
class XCanvas;
+ struct Texture;
class XIntegerBitmapColorSpace;
class XPolyPolygon2D;
@@ -499,6 +500,18 @@ namespace canvas
*/
::basegfx::B2DPolyPolygon getBoundMarksPolyPolygon( const ::basegfx::B2DRange& rRange );
+ /** Calculate number of gradient "strips" to generate (takes
+ into account device resolution)
+
+ @param nColorSteps
+ Maximal integer difference between all color stops, needed
+ for smooth gradient color differences
+ */
+ int calcGradientStepCount( ::basegfx::B2DHomMatrix& rTotalTransform,
+ const ::com::sun::star::rendering::ViewState& viewState,
+ const ::com::sun::star::rendering::RenderState& renderState,
+ const ::com::sun::star::rendering::Texture& texture,
+ int nColorSteps );
/** A very simplistic map for ASCII strings and arbitrary value
types.
diff --git a/canvas/source/directx/dx_canvashelper_texturefill.cxx b/canvas/source/directx/dx_canvashelper_texturefill.cxx
index 453569298004..ab0f399b2901 100755
--- a/canvas/source/directx/dx_canvashelper_texturefill.cxx
+++ b/canvas/source/directx/dx_canvashelper_texturefill.cxx
@@ -41,6 +41,7 @@
#include <basegfx/point/b2dpoint.hxx>
#include <basegfx/range/b2drectangle.hxx>
#include <basegfx/numeric/ftools.hxx>
+#include <basegfx/polygon/b2dpolygontools.hxx>
#include <basegfx/tools/tools.hxx>
#include <basegfx/tools/lerp.hxx>
#include <basegfx/tools/keystoplerp.hxx>
@@ -67,7 +68,7 @@ namespace dxcanvas
typedef ::boost::shared_ptr< Gdiplus::PathGradientBrush > PathGradientBrushSharedPtr;
bool fillLinearGradient( GraphicsSharedPtr& rGraphics,
- const ::canvas::ParametricPolyPolygon::Values& rValues,
+ const ::canvas::ParametricPolyPolygon::Values& /*rValues*/,
const std::vector< Gdiplus::Color >& rColors,
const std::vector< Gdiplus::REAL >& rStops,
const GraphicsPathSharedPtr& rFillPath,
@@ -214,23 +215,14 @@ namespace dxcanvas
const std::vector< Gdiplus::REAL >& rStops,
GraphicsSharedPtr& rGraphics,
const GraphicsPathSharedPtr& rPath,
+ const rendering::ViewState& viewState,
+ const rendering::RenderState& renderState,
const rendering::Texture& texture )
{
- Gdiplus::Matrix aMatrix;
- tools::gdiPlusMatrixFromAffineMatrix2D( aMatrix,
- texture.AffineTransform );
-
// copy original fill path object, might have to change it
// below
GraphicsPathSharedPtr pFillPath( rPath );
-
- // clone original gradient path object, we need to change it
- // below
- GraphicsPathSharedPtr pGradientPath(
- tools::graphicsPathFromB2DPolygon( rValues.maGradientPoly ) );
-
- ENSURE_OR_RETURN( pGradientPath.get(),
- "ParametricPolyPolygon::fillPolygonalGradient(): Could not clone path" );
+ const ::basegfx::B2DPolygon& rGradientPoly( rValues.maGradientPoly );
PathGradientBrushSharedPtr pGradientBrush;
@@ -264,8 +256,6 @@ namespace dxcanvas
return false;
}
- rGraphics->MultiplyTransform( &aMatrix );
-
// disable anti-aliasing, if any
const Gdiplus::SmoothingMode eOldAAMode( rGraphics->GetSmoothingMode() );
rGraphics->SetSmoothingMode( Gdiplus::SmoothingModeHighSpeed );
@@ -278,50 +268,80 @@ namespace dxcanvas
int nColorSteps = 0;
for( size_t i=0; i<rColors.size()-1; ++i )
nColorSteps += numColorSteps(rColors[i],rColors[i+1]);
+ ::basegfx::B2DHomMatrix aTotalTransform;
+ const int nStepCount=
+ ::canvas::tools::calcGradientStepCount(aTotalTransform,
+ viewState,
+ renderState,
+ texture,
+ nColorSteps);
+
+ ::basegfx::B2DHomMatrix aTextureTransform;
+ ::basegfx::unotools::homMatrixFromAffineMatrix( aTextureTransform,
+ texture.AffineTransform );
+ // determine overall transformation for inner polygon (might
+ // have to be prefixed by anisotrophic scaling)
+ ::basegfx::B2DHomMatrix aInnerPolygonTransformMatrix;
+
+ // For performance reasons, we create a temporary VCL polygon
+ // here, keep it all the way and only change the vertex values
+ // in the loop below (as ::Polygon is a pimpl class, creating
+ // one every loop turn would really stress the mem allocator)
+ ::basegfx::B2DPolygon aOuterPoly( rGradientPoly );
+ ::basegfx::B2DPolygon aInnerPoly;
+
+ // subdivide polygon _before_ rendering, would otherwise have
+ // to be performed on every loop turn.
+ if( aOuterPoly.areControlPointsUsed() )
+ aOuterPoly = ::basegfx::tools::adaptiveSubdivideByAngle(aOuterPoly);
+
+ aInnerPoly = aOuterPoly;
+ aOuterPoly.transform(aTextureTransform);
+
+
+ // apply scaling (possibly anisotrophic) to inner polygon
+ // ------------------------------------------------------
+
+ // scale inner polygon according to aspect ratio: for
+ // wider-than-tall bounds (nAspectRatio > 1.0), the inner
+ // polygon, representing the gradient focus, must have
+ // non-zero width. Specifically, a bound rect twice as wide as
+ // tall has a focus polygon of half it's width.
+ const double nAspectRatio( rValues.mnAspectRatio );
+ if( nAspectRatio > 1.0 )
+ {
+ // width > height case
+ aInnerPolygonTransformMatrix.scale( 1.0 - 1.0/nAspectRatio,
+ 0.0 );
+ }
+ else if( nAspectRatio < 1.0 )
+ {
+ // width < height case
+ aInnerPolygonTransformMatrix.scale( 0.0,
+ 1.0 - nAspectRatio );
+ }
+ else
+ {
+ // isotrophic case
+ aInnerPolygonTransformMatrix.scale( 0.0, 0.0 );
+ }
+
+ // and finally, add texture transform to it.
+ aInnerPolygonTransformMatrix *= aTextureTransform;
- Gdiplus::Matrix aWorldTransformMatrix;
- rGraphics->GetTransform( &aWorldTransformMatrix );
-
- Gdiplus::RectF aBounds;
- pGradientPath->GetBounds( &aBounds, &aWorldTransformMatrix, NULL );
-
- // longest line in gradient bound rect
- const int nGradientSize(
- static_cast<int>( hypot( aBounds.Width, aBounds.Height ) + 1.0 ) );
-
- // typical number for pixel of the same color (strip size)
- const int nStripSize( nGradientSize < 50 ? 2 : 4 );
-
- // use at least three steps, and at utmost the number of color
- // steps
- const int nStepCount(
- ::std::max(
- 3,
- ::std::min(
- nGradientSize / nStripSize,
- nColorSteps ) ) );
-
- Gdiplus::SolidBrush aFillBrush( rColors[0] );
- Gdiplus::Matrix aGDIScaleMatrix;
- ::basegfx::B2DHomMatrix aScaleMatrix;
-
- // calc relative size for anisotrophic polygon scaling:
- // when the aspect ratio is e.g. 2.0, that denotes a
- // gradient which is twice as wide as high. Then, to
- // generate a symmetric gradient, the x direction is only
- // scaled to 0.5 times the gradient width. Similarly, when
- // the aspect ratio is 4.0, the focus has 3/4 the width of
- // the overall gradient.
- const double nRelativeFocusSize( rValues.mnAspectRatio > 1.0 ?
- 1.0 - 1.0/rValues.mnAspectRatio :
- 1.0 - rValues.mnAspectRatio );
+ // apply final matrix to polygon
+ aInnerPoly.transform( aInnerPolygonTransformMatrix );
+ Gdiplus::GraphicsPath aCurrPath;
+ Gdiplus::SolidBrush aFillBrush( rColors[0] );
+ const sal_uInt32 nNumPoints( aOuterPoly.count() );
basegfx::tools::KeyStopLerp aLerper(rValues.maStops);
for( int i=1; i<nStepCount; ++i )
{
std::ptrdiff_t nIndex;
double fAlpha;
- boost::tuples::tie(nIndex,fAlpha)=aLerper.lerp(double(i)/nStepCount);
+ const double fT( i/double(nStepCount) );
+ boost::tuples::tie(nIndex,fAlpha)=aLerper.lerp(fT);
const Gdiplus::Color aFillColor(
static_cast<BYTE>( basegfx::tools::lerp(rColors[nIndex].GetRed(),rColors[nIndex+1].GetRed(),fAlpha) ),
@@ -329,45 +349,23 @@ namespace dxcanvas
static_cast<BYTE>( basegfx::tools::lerp(rColors[nIndex].GetBlue(),rColors[nIndex+1].GetBlue(),fAlpha) ) );
aFillBrush.SetColor( aFillColor );
-
- const double nCurrScale( (nStepCount-i)/(double)nStepCount );
- aScaleMatrix = basegfx::tools::createTranslateB2DHomMatrix(-0.5, -0.5);
-
- // handle anisotrophic polygon scaling
- if( rValues.mnAspectRatio < 1.0 )
- {
- // height > width case
- aScaleMatrix.scale( nCurrScale,
- // lerp with nCurrScale
- // between 1.0 and
- // relative focus height
- nCurrScale + (1.0-nCurrScale)*nRelativeFocusSize );
- }
- else if( rValues.mnAspectRatio > 1.0 )
- {
- // width > height case
- aScaleMatrix.scale( nCurrScale + (1.0-nCurrScale)*nRelativeFocusSize,
- // lerp with nCurrScale
- // between 1.0 and
- // relative focus width
- nCurrScale );
- }
- else
+ aCurrPath.Reset(); aCurrPath.StartFigure();
+ for( unsigned int p=1; p<nNumPoints; ++p )
{
- aScaleMatrix.scale( nCurrScale,
- nCurrScale );
+ const ::basegfx::B2DPoint& rOuterPoint1( aOuterPoly.getB2DPoint(p-1) );
+ const ::basegfx::B2DPoint& rInnerPoint1( aInnerPoly.getB2DPoint(p-1) );
+ const ::basegfx::B2DPoint& rOuterPoint2( aOuterPoly.getB2DPoint(p) );
+ const ::basegfx::B2DPoint& rInnerPoint2( aInnerPoly.getB2DPoint(p) );
+
+ aCurrPath.AddLine(
+ Gdiplus::REAL(fT*rInnerPoint1.getX() + (1-fT)*rOuterPoint1.getX()),
+ Gdiplus::REAL(fT*rInnerPoint1.getY() + (1-fT)*rOuterPoint1.getY()),
+ Gdiplus::REAL(fT*rInnerPoint2.getX() + (1-fT)*rOuterPoint2.getX()),
+ Gdiplus::REAL(fT*rInnerPoint2.getY() + (1-fT)*rOuterPoint2.getY()));
}
+ aCurrPath.CloseFigure();
- aScaleMatrix.translate( 0.5, 0.5 );
-
- tools::gdiPlusMatrixFromB2DHomMatrix( aGDIScaleMatrix,
- aScaleMatrix );
-
- GraphicsPathSharedPtr pScaledGradientPath(
- tools::graphicsPathFromB2DPolygon( rValues.maGradientPoly ) );
- pScaledGradientPath->Transform( &aGDIScaleMatrix );
-
- rGraphics->FillPath( &aFillBrush, pScaledGradientPath.get() );
+ rGraphics->FillPath( &aFillBrush, &aCurrPath );
}
// reset to old anti-alias mode
@@ -388,6 +386,11 @@ namespace dxcanvas
// one sets both, only the translational components of the
// texture is respected.
+ Gdiplus::Matrix aMatrix;
+ tools::gdiPlusMatrixFromAffineMatrix2D( aMatrix,
+ texture.AffineTransform );
+ GraphicsPathSharedPtr pGradientPath(
+ tools::graphicsPathFromB2DPolygon( rValues.maGradientPoly ));
pGradientPath->Transform( &aMatrix );
pGradientBrush.reset(
@@ -400,7 +403,7 @@ namespace dxcanvas
// gradients are by default the _centroid_ of the path
// (i.e. the weighted sum of edge points), it will not
// necessarily coincide with our notion of center.
- Gdiplus::PointF aCenterPoint(0.5, 0.5);
+ Gdiplus::PointF aCenterPoint(0, 0);
aMatrix.TransformPoints( &aCenterPoint );
pGradientBrush->SetCenterPoint( aCenterPoint );
@@ -440,6 +443,8 @@ namespace dxcanvas
const std::vector< Gdiplus::REAL >& rStops,
GraphicsSharedPtr& rGraphics,
const GraphicsPathSharedPtr& rPath,
+ const rendering::ViewState& viewState,
+ const rendering::RenderState& renderState,
const rendering::Texture& texture )
{
switch( rValues.meType )
@@ -461,6 +466,8 @@ namespace dxcanvas
rStops,
rGraphics,
rPath,
+ viewState,
+ renderState,
texture );
break;
@@ -486,8 +493,8 @@ namespace dxcanvas
const geometry::IntegerSize2D aBmpSize( xBitmap->getSize() );
ENSURE_ARG_OR_THROW( aBmpSize.Width != 0 &&
- aBmpSize.Height != 0,
- "CanvasHelper::fillBitmap(): zero-sized texture bitmap" );
+ aBmpSize.Height != 0,
+ "CanvasHelper::fillBitmap(): zero-sized texture bitmap" );
// TODO(P3): Detect case that path is rectangle and
// bitmap is just scaled into that. Then, we can
@@ -499,7 +506,6 @@ namespace dxcanvas
tools::bitmapFromXBitmap( xBitmap ) );
TextureBrushSharedPtr pBrush;
-
if( ::rtl::math::approxEqual( rTexture.Alpha,
1.0 ) )
{
@@ -537,9 +543,9 @@ namespace dxcanvas
// scale down bitmap to [0,1]x[0,1] rect, as required
// from the XCanvas interface.
+ pBrush->MultiplyTransform( &aTextureTransform );
pBrush->ScaleTransform( static_cast< Gdiplus::REAL >(1.0/aBmpSize.Width),
static_cast< Gdiplus::REAL >(1.0/aBmpSize.Height) );
- pBrush->MultiplyTransform( &aTextureTransform );
// TODO(F1): FillRule
ENSURE_OR_THROW(
@@ -602,6 +608,8 @@ namespace dxcanvas
aStops,
pGraphics,
tools::graphicsPathFromXPolyPolygon2D( xPolyPolygon ),
+ viewState,
+ renderState,
textures[0] );
}
}
diff --git a/canvas/source/directx/dx_impltools.cxx b/canvas/source/directx/dx_impltools.cxx
index 4f5b92d6bcb5..0067ea8e9b71 100755
--- a/canvas/source/directx/dx_impltools.cxx
+++ b/canvas/source/directx/dx_impltools.cxx
@@ -199,7 +199,7 @@ namespace dxcanvas
{
const sal_uInt32 nPoints( rPoly.count() );
- if( !nPoints )
+ if( nPoints < 2 )
return;
rOutput->StartFigure();
diff --git a/canvas/source/tools/canvastools.cxx b/canvas/source/tools/canvastools.cxx
index 278789637c72..eabc8b847374 100644..100755
--- a/canvas/source/tools/canvastools.cxx
+++ b/canvas/source/tools/canvastools.cxx
@@ -994,6 +994,54 @@ namespace canvas
return aPolyPoly;
}
+ int calcGradientStepCount( ::basegfx::B2DHomMatrix& rTotalTransform,
+ const rendering::ViewState& viewState,
+ const rendering::RenderState& renderState,
+ const rendering::Texture& texture,
+ int nColorSteps )
+ {
+ // calculate overall texture transformation (directly from
+ // texture to device space).
+ ::basegfx::B2DHomMatrix aMatrix;
+
+ rTotalTransform.identity();
+ ::basegfx::unotools::homMatrixFromAffineMatrix( rTotalTransform,
+ texture.AffineTransform );
+ ::canvas::tools::mergeViewAndRenderTransform(aMatrix,
+ viewState,
+ renderState);
+ rTotalTransform *= aMatrix; // prepend total view/render transformation
+
+ // determine size of gradient in device coordinate system
+ // (to e.g. determine sensible number of gradient steps)
+ ::basegfx::B2DPoint aLeftTop( 0.0, 0.0 );
+ ::basegfx::B2DPoint aLeftBottom( 0.0, 1.0 );
+ ::basegfx::B2DPoint aRightTop( 1.0, 0.0 );
+ ::basegfx::B2DPoint aRightBottom( 1.0, 1.0 );
+
+ aLeftTop *= rTotalTransform;
+ aLeftBottom *= rTotalTransform;
+ aRightTop *= rTotalTransform;
+ aRightBottom*= rTotalTransform;
+
+ // longest line in gradient bound rect
+ const int nGradientSize(
+ static_cast<int>(
+ ::std::max(
+ ::basegfx::B2DVector(aRightBottom-aLeftTop).getLength(),
+ ::basegfx::B2DVector(aRightTop-aLeftBottom).getLength() ) + 1.0 ) );
+
+ // typical number for pixel of the same color (strip size)
+ const int nStripSize( nGradientSize < 50 ? 2 : 4 );
+
+ // use at least three steps, and at utmost the number of color
+ // steps
+ return ::std::max( 3,
+ ::std::min(
+ nGradientSize / nStripSize,
+ nColorSteps ) );
+ }
+
} // namespace tools
} // namespace canvas
diff --git a/canvas/source/vcl/canvashelper_texturefill.cxx b/canvas/source/vcl/canvashelper_texturefill.cxx
index 9f8118e8a8f8..841d78375f82 100644..100755
--- a/canvas/source/vcl/canvashelper_texturefill.cxx
+++ b/canvas/source/vcl/canvashelper_texturefill.cxx
@@ -562,62 +562,27 @@ namespace vclcanvas
// deadlocks, canvashelper calls this method with locked own
// mutex.
- // calculate overall texture transformation (directly from
- // texture to device space).
- ::basegfx::B2DHomMatrix aMatrix;
- ::basegfx::B2DHomMatrix aTextureTransform;
-
- ::basegfx::unotools::homMatrixFromAffineMatrix( aTextureTransform,
- texture.AffineTransform );
- ::canvas::tools::mergeViewAndRenderTransform(aMatrix,
- viewState,
- renderState);
- aTextureTransform *= aMatrix; // prepend total view/render transformation
-
- // determine maximal bound rect of gradient-filled polygon
- const ::Rectangle aPolygonDeviceRectOrig(
- rPoly.GetBoundRect() );
-
- // determine size of gradient in device coordinate system
- // (to e.g. determine sensible number of gradient steps)
- ::basegfx::B2DPoint aLeftTop( 0.0, 0.0 );
- ::basegfx::B2DPoint aLeftBottom( 0.0, 1.0 );
- ::basegfx::B2DPoint aRightTop( 1.0, 0.0 );
- ::basegfx::B2DPoint aRightBottom( 1.0, 1.0 );
-
- aLeftTop *= aTextureTransform;
- aLeftBottom *= aTextureTransform;
- aRightTop *= aTextureTransform;
- aRightBottom*= aTextureTransform;
-
-
// calc step size
// --------------
int nColorSteps = 0;
for( size_t i=0; i<rColors.size()-1; ++i )
nColorSteps += numColorSteps(rColors[i],rColors[i+1]);
- // longest line in gradient bound rect
- const int nGradientSize(
- static_cast<int>(
- ::std::max(
- ::basegfx::B2DVector(aRightBottom-aLeftTop).getLength(),
- ::basegfx::B2DVector(aRightTop-aLeftBottom).getLength() ) + 1.0 ) );
-
- // typical number for pixel of the same color (strip size)
- const int nStripSize( nGradientSize < 50 ? 2 : 4 );
-
- // use at least three steps, and at utmost the number of color
- // steps
- const int nStepCount(
- ::std::max(
- 3,
- ::std::min(
- nGradientSize / nStripSize,
- nColorSteps ) ) );
+ ::basegfx::B2DHomMatrix aTotalTransform;
+ const int nStepCount=
+ ::canvas::tools::calcGradientStepCount(aTotalTransform,
+ viewState,
+ renderState,
+ texture,
+ nColorSteps);
rOutDev.SetLineColor();
+ // determine maximal bound rect of texture-filled
+ // polygon
+ const ::Rectangle aPolygonDeviceRectOrig(
+ rPoly.GetBoundRect() );
+
if( tools::isRectangle( rPoly ) )
{
// use optimized output path
@@ -635,7 +600,7 @@ namespace vclcanvas
doGradientFill( rOutDev,
rValues,
rColors,
- aTextureTransform,
+ aTotalTransform,
aPolygonDeviceRectOrig,
nStepCount,
false );
@@ -648,7 +613,7 @@ namespace vclcanvas
doGradientFill( *p2ndOutDev,
rValues,
rColors,
- aTextureTransform,
+ aTotalTransform,
aPolygonDeviceRectOrig,
nStepCount,
false );
@@ -666,7 +631,7 @@ namespace vclcanvas
doGradientFill( rOutDev,
rValues,
rColors,
- aTextureTransform,
+ aTotalTransform,
aPolygonDeviceRectOrig,
nStepCount,
false );
@@ -679,7 +644,7 @@ namespace vclcanvas
doGradientFill( *p2ndOutDev,
rValues,
rColors,
- aTextureTransform,
+ aTotalTransform,
aPolygonDeviceRectOrig,
nStepCount,
false );
@@ -694,7 +659,7 @@ namespace vclcanvas
doGradientFill( rOutDev,
rValues,
rColors,
- aTextureTransform,
+ aTotalTransform,
aPolygonDeviceRectOrig,
nStepCount,
true );
@@ -705,7 +670,7 @@ namespace vclcanvas
doGradientFill( rOutDev,
rValues,
rColors,
- aTextureTransform,
+ aTotalTransform,
aPolygonDeviceRectOrig,
nStepCount,
true );
@@ -718,7 +683,7 @@ namespace vclcanvas
doGradientFill( *p2ndOutDev,
rValues,
rColors,
- aTextureTransform,
+ aTotalTransform,
aPolygonDeviceRectOrig,
nStepCount,
true );
@@ -729,7 +694,7 @@ namespace vclcanvas
doGradientFill( *p2ndOutDev,
rValues,
rColors,
- aTextureTransform,
+ aTotalTransform,
aPolygonDeviceRectOrig,
nStepCount,
true );
generated by cgit (git 2.34.1) at 2025-01-18 03:51:47 +0000