drawinglayer/source/texture/texture.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <drawinglayer/texture/texture.hxx>
  21 #include <drawinglayer/tools/converters.hxx>
  22 #include <basegfx/numeric/ftools.hxx>
  23 #include <basegfx/tools/gradienttools.hxx>
  24 #include <basegfx/matrix/b2dhommatrixtools.hxx>
  25
  26 namespace drawinglayer
  27 {
  28     namespace texture
  29     {
  30         GeoTexSvx::GeoTexSvx()
  31         {
  32         }
  33
  34         GeoTexSvx::~GeoTexSvx()
  35         {
  36         }
  37
  38         bool GeoTexSvx::operator==(const GeoTexSvx& /*rGeoTexSvx*/) const
  39         {
  40             // default implementation says yes (no data -> no difference)
  41             return true;
  42         }
  43
  44         void GeoTexSvx::modifyBColor(const basegfx::B2DPoint& /*rUV*/, basegfx::BColor& rBColor, double& /*rfOpacity*/) const
  45         {
  46             // base implementation creates random color (for testing only, may also be pure virtual)
  47             rBColor.setRed(tools::getRandomColorRange());
  48             rBColor.setGreen(tools::getRandomColorRange());
  49             rBColor.setBlue(tools::getRandomColorRange());
  50         }
  51
  52         void GeoTexSvx::modifyOpacity(const basegfx::B2DPoint& rUV, double& rfOpacity) const
  53         {
  54             // base implementation uses inverse of luminance of solved color (for testing only, may also be pure virtual)
  55             basegfx::BColor aBaseColor;
  56             modifyBColor(rUV, aBaseColor, rfOpacity);
  57             rfOpacity = 1.0 - aBaseColor.luminance();
  58         }
  59     } // end of namespace texture
  60 } // end of namespace drawinglayer
  61
  62
  63 namespace drawinglayer
  64 {
  65     namespace texture
  66     {
  67         GeoTexSvxGradient::GeoTexSvxGradient(
  68             const basegfx::B2DRange& rDefinitionRange,
  69             const basegfx::BColor& rStart,
  70             const basegfx::BColor& rEnd,
  71             sal_uInt32 /* nSteps */,
  72             double fBorder)
  73         :   GeoTexSvx(),
  74             maGradientInfo(),
  75             maDefinitionRange(rDefinitionRange),
  76             maStart(rStart),
  77             maEnd(rEnd),
  78             mfBorder(fBorder)
  79         {
  80         }
  81
  82         GeoTexSvxGradient::~GeoTexSvxGradient()
  83         {
  84         }
  85
  86         bool GeoTexSvxGradient::operator==(const GeoTexSvx& rGeoTexSvx) const
  87         {
  88             const GeoTexSvxGradient* pCompare = dynamic_cast< const GeoTexSvxGradient* >(&rGeoTexSvx);
  89
  90             return (pCompare
  91                 && maGradientInfo == pCompare->maGradientInfo
  92                 && maDefinitionRange == pCompare->maDefinitionRange
  93                 && mfBorder == pCompare->mfBorder);
  94         }
  95     } // end of namespace texture
  96 } // end of namespace drawinglayer
  97
  98
  99 namespace drawinglayer
 100 {
 101     namespace texture
 102     {
 103         GeoTexSvxGradientLinear::GeoTexSvxGradientLinear(
 104             const basegfx::B2DRange& rDefinitionRange,
 105             const basegfx::B2DRange& rOutputRange,
 106             const basegfx::BColor& rStart,
 107             const basegfx::BColor& rEnd,
 108             sal_uInt32 nSteps,
 109             double fBorder,
 110             double fAngle)
 111         :   GeoTexSvxGradient(rDefinitionRange, rStart, rEnd, nSteps, fBorder),
 112             mfUnitMinX(0.0),
 113             mfUnitWidth(1.0),
 114             mfUnitMaxY(1.0)
 115         {
 116             maGradientInfo = basegfx::tools::createLinearODFGradientInfo(
 117                 rDefinitionRange,
 118                 nSteps,
 119                 fBorder,
 120                 fAngle);
 121
 122             if(rDefinitionRange != rOutputRange)
 123             {
 124                 basegfx::B2DRange aInvOutputRange(rOutputRange);
 125
 126                 aInvOutputRange.transform(maGradientInfo.getBackTextureTransform());
 127                 mfUnitMinX = aInvOutputRange.getMinX();
 128                 mfUnitWidth = aInvOutputRange.getWidth();
 129                 mfUnitMaxY = aInvOutputRange.getMaxY();
 130             }
 131         }
 132
 133         GeoTexSvxGradientLinear::~GeoTexSvxGradientLinear()
 134         {
 135         }
 136
 137         void GeoTexSvxGradientLinear::appendTransformationsAndColors(
 138             std::vector< B2DHomMatrixAndBColor >& rEntries,
 139             basegfx::BColor& rOuterColor)
 140         {
 141             rOuterColor = maStart;
 142
 143             if(maGradientInfo.getSteps())
 144             {
 145                 const double fStripeWidth(1.0 / maGradientInfo.getSteps());
 146                 B2DHomMatrixAndBColor aB2DHomMatrixAndBColor;
 147                 basegfx::B2DHomMatrix aPattern;
 148
 149                 // bring from unit circle [-1, -1, 1, 1] to unit range [0, 0, 1, 1]
 150                 aPattern.scale(0.5, 0.5);
 151                 aPattern.translate(0.5, 0.5);
 152
 153                 // scale and translate in X
 154                 aPattern.scale(mfUnitWidth, 1.0);
 155                 aPattern.translate(mfUnitMinX, 0.0);
 156
 157                 for(sal_uInt32 a(1); a < maGradientInfo.getSteps(); a++)
 158                 {
 159                     const double fPos(fStripeWidth * a);
 160                     basegfx::B2DHomMatrix aNew(aPattern);
 161
 162                     // scale and translate in Y
 163                     double fHeight(1.0 - fPos);
 164
 165                     if(a + 1 == maGradientInfo.getSteps() && mfUnitMaxY > 1.0)
 166                     {
 167                         fHeight += mfUnitMaxY - 1.0;
 168                     }
 169
 170                     aNew.scale(1.0, fHeight);
 171                     aNew.translate(0.0, fPos);
 172
 173                     // set at target
 174                     aB2DHomMatrixAndBColor.maB2DHomMatrix = maGradientInfo.getTextureTransform() * aNew;
 175
 176                     // interpolate and set color
 177                     aB2DHomMatrixAndBColor.maBColor = interpolate(maStart, maEnd, double(a) / double(maGradientInfo.getSteps() - 1));
 178
 179                     rEntries.push_back(aB2DHomMatrixAndBColor);
 180                 }
 181             }
 182         }
 183
 184         void GeoTexSvxGradientLinear::modifyBColor(const basegfx::B2DPoint& rUV, basegfx::BColor& rBColor, double& /*rfOpacity*/) const
 185         {
 186             const double fScaler(basegfx::tools::getLinearGradientAlpha(rUV, maGradientInfo));
 187
 188             rBColor = basegfx::interpolate(maStart, maEnd, fScaler);
 189         }
 190     } // end of namespace texture
 191 } // end of namespace drawinglayer
 192
 193
 194 namespace drawinglayer
 195 {
 196     namespace texture
 197     {
 198         GeoTexSvxGradientAxial::GeoTexSvxGradientAxial(
 199             const basegfx::B2DRange& rDefinitionRange,
 200             const basegfx::B2DRange& rOutputRange,
 201             const basegfx::BColor& rStart,
 202             const basegfx::BColor& rEnd,
 203             sal_uInt32 nSteps,
 204             double fBorder,
 205             double fAngle)
 206         :   GeoTexSvxGradient(rDefinitionRange, rStart, rEnd, nSteps, fBorder),
 207             mfUnitMinX(0.0),
 208             mfUnitWidth(1.0)
 209         {
 210             maGradientInfo = basegfx::tools::createAxialODFGradientInfo(
 211                 rDefinitionRange,
 212                 nSteps,
 213                 fBorder,
 214                 fAngle);
 215
 216             if(rDefinitionRange != rOutputRange)
 217             {
 218                 basegfx::B2DRange aInvOutputRange(rOutputRange);
 219
 220                 aInvOutputRange.transform(maGradientInfo.getBackTextureTransform());
 221                 mfUnitMinX = aInvOutputRange.getMinX();
 222                 mfUnitWidth = aInvOutputRange.getWidth();
 223             }
 224         }
 225
 226         GeoTexSvxGradientAxial::~GeoTexSvxGradientAxial()
 227         {
 228         }
 229
 230         void GeoTexSvxGradientAxial::appendTransformationsAndColors(
 231             std::vector< B2DHomMatrixAndBColor >& rEntries,
 232             basegfx::BColor& rOuterColor)
 233         {
 234             rOuterColor = maEnd;
 235
 236             if(maGradientInfo.getSteps())
 237             {
 238                 const double fStripeWidth(1.0 / maGradientInfo.getSteps());
 239                 B2DHomMatrixAndBColor aB2DHomMatrixAndBColor;
 240
 241                 for(sal_uInt32 a(1); a < maGradientInfo.getSteps(); a++)
 242                 {
 243                     const double fPos(fStripeWidth * a);
 244                     basegfx::B2DHomMatrix aNew;
 245
 246                     // bring in X from unit circle [-1, -1, 1, 1] to unit range [0, 0, 1, 1]
 247                     aNew.scale(0.5, 1.0);
 248                     aNew.translate(0.5, 0.0);
 249
 250                     // scale/translate in X
 251                     aNew.scale(mfUnitWidth, 1.0);
 252                     aNew.translate(mfUnitMinX, 0.0);
 253
 254                     // already centered in Y on X-Axis, just scale in Y
 255                     aNew.scale(1.0, 1.0 - fPos);
 256
 257                     // set at target
 258                     aB2DHomMatrixAndBColor.maB2DHomMatrix = maGradientInfo.getTextureTransform() * aNew;
 259
 260                     // interpolate and set color
 261                     aB2DHomMatrixAndBColor.maBColor = interpolate(maEnd, maStart, double(a) / double(maGradientInfo.getSteps() - 1));
 262
 263                     rEntries.push_back(aB2DHomMatrixAndBColor);
 264                 }
 265             }
 266         }
 267
 268         void GeoTexSvxGradientAxial::modifyBColor(const basegfx::B2DPoint& rUV, basegfx::BColor& rBColor, double& /*rfOpacity*/) const
 269         {
 270             const double fScaler(basegfx::tools::getAxialGradientAlpha(rUV, maGradientInfo));
 271
 272             rBColor = basegfx::interpolate(maStart, maEnd, fScaler);
 273         }
 274     } // end of namespace texture
 275 } // end of namespace drawinglayer
 276
 277
 278 namespace drawinglayer
 279 {
 280     namespace texture
 281     {
 282         GeoTexSvxGradientRadial::GeoTexSvxGradientRadial(
 283             const basegfx::B2DRange& rDefinitionRange,
 284             const basegfx::BColor& rStart,
 285             const basegfx::BColor& rEnd,
 286             sal_uInt32 nSteps,
 287             double fBorder,
 288             double fOffsetX,
 289             double fOffsetY)
 290         :   GeoTexSvxGradient(rDefinitionRange, rStart, rEnd, nSteps, fBorder)
 291         {
 292             maGradientInfo = basegfx::tools::createRadialODFGradientInfo(
 293                 rDefinitionRange,
 294                 basegfx::B2DVector(fOffsetX,fOffsetY),
 295                 nSteps,
 296                 fBorder);
 297         }
 298
 299         GeoTexSvxGradientRadial::~GeoTexSvxGradientRadial()
 300         {
 301         }
 302
 303         void GeoTexSvxGradientRadial::appendTransformationsAndColors(
 304             std::vector< B2DHomMatrixAndBColor >& rEntries,
 305             basegfx::BColor& rOuterColor)
 306         {
 307             rOuterColor = maStart;
 308
 309             if(maGradientInfo.getSteps())
 310             {
 311                 const double fStepSize(1.0 / maGradientInfo.getSteps());
 312                 B2DHomMatrixAndBColor aB2DHomMatrixAndBColor;
 313
 314                 for(sal_uInt32 a(1); a < maGradientInfo.getSteps(); a++)
 315                 {
 316                     const double fSize(1.0 - (fStepSize * a));
 317                     aB2DHomMatrixAndBColor.maB2DHomMatrix = maGradientInfo.getTextureTransform() * basegfx::tools::createScaleB2DHomMatrix(fSize, fSize);
 318                     aB2DHomMatrixAndBColor.maBColor = interpolate(maStart, maEnd, double(a) / double(maGradientInfo.getSteps() - 1));
 319                     rEntries.push_back(aB2DHomMatrixAndBColor);
 320                 }
 321             }
 322         }
 323
 324         void GeoTexSvxGradientRadial::modifyBColor(const basegfx::B2DPoint& rUV, basegfx::BColor& rBColor, double& /*rfOpacity*/) const
 325         {
 326             const double fScaler(basegfx::tools::getRadialGradientAlpha(rUV, maGradientInfo));
 327
 328             rBColor = basegfx::interpolate(maStart, maEnd, fScaler);
 329         }
 330     } // end of namespace texture
 331 } // end of namespace drawinglayer
 332
 333
 334 namespace drawinglayer
 335 {
 336     namespace texture
 337     {
 338         GeoTexSvxGradientElliptical::GeoTexSvxGradientElliptical(
 339             const basegfx::B2DRange& rDefinitionRange,
 340             const basegfx::BColor& rStart,
 341             const basegfx::BColor& rEnd,
 342             sal_uInt32 nSteps,
 343             double fBorder,
 344             double fOffsetX,
 345             double fOffsetY,
 346             double fAngle)
 347         :   GeoTexSvxGradient(rDefinitionRange, rStart, rEnd, nSteps, fBorder)
 348         {
 349             maGradientInfo = basegfx::tools::createEllipticalODFGradientInfo(
 350                 rDefinitionRange,
 351                 basegfx::B2DVector(fOffsetX,fOffsetY),
 352                 nSteps,
 353                 fBorder,
 354                 fAngle);
 355         }
 356
 357         GeoTexSvxGradientElliptical::~GeoTexSvxGradientElliptical()
 358         {
 359         }
 360
 361         void GeoTexSvxGradientElliptical::appendTransformationsAndColors(
 362             std::vector< B2DHomMatrixAndBColor >& rEntries,
 363             basegfx::BColor& rOuterColor)
 364         {
 365             rOuterColor = maStart;
 366
 367             if(maGradientInfo.getSteps())
 368             {
 369                 double fWidth(1.0);
 370                 double fHeight(1.0);
 371                 double fIncrementX(0.0);
 372                 double fIncrementY(0.0);
 373
 374                 if(maGradientInfo.getAspectRatio() > 1.0)
 375                 {
 376                     fIncrementY = fHeight / maGradientInfo.getSteps();
 377                     fIncrementX = fIncrementY / maGradientInfo.getAspectRatio();
 378                 }
 379                 else
 380                 {
 381                     fIncrementX = fWidth / maGradientInfo.getSteps();
 382                     fIncrementY = fIncrementX * maGradientInfo.getAspectRatio();
 383                 }
 384
 385                 B2DHomMatrixAndBColor aB2DHomMatrixAndBColor;
 386
 387                 for(sal_uInt32 a(1); a < maGradientInfo.getSteps(); a++)
 388                 {
 389                     // next step
 390                     fWidth -= fIncrementX;
 391                     fHeight -= fIncrementY;
 392
 393                     aB2DHomMatrixAndBColor.maB2DHomMatrix = maGradientInfo.getTextureTransform() * basegfx::tools::createScaleB2DHomMatrix(fWidth, fHeight);
 394                     aB2DHomMatrixAndBColor.maBColor = interpolate(maStart, maEnd, double(a) / double(maGradientInfo.getSteps() - 1));
 395                     rEntries.push_back(aB2DHomMatrixAndBColor);
 396                 }
 397             }
 398         }
 399
 400         void GeoTexSvxGradientElliptical::modifyBColor(const basegfx::B2DPoint& rUV, basegfx::BColor& rBColor, double& /*rfOpacity*/) const
 401         {
 402             const double fScaler(basegfx::tools::getEllipticalGradientAlpha(rUV, maGradientInfo));
 403
 404             rBColor = basegfx::interpolate(maStart, maEnd, fScaler);
 405         }
 406     } // end of namespace texture
 407 } // end of namespace drawinglayer
 408
 409
 410 namespace drawinglayer
 411 {
 412     namespace texture
 413     {
 414         GeoTexSvxGradientSquare::GeoTexSvxGradientSquare(
 415             const basegfx::B2DRange& rDefinitionRange,
 416             const basegfx::BColor& rStart,
 417             const basegfx::BColor& rEnd,
 418             sal_uInt32 nSteps,
 419             double fBorder,
 420             double fOffsetX,
 421             double fOffsetY,
 422             double fAngle)
 423         :   GeoTexSvxGradient(rDefinitionRange, rStart, rEnd, nSteps, fBorder)
 424         {
 425             maGradientInfo = basegfx::tools::createSquareODFGradientInfo(
 426                 rDefinitionRange,
 427                 basegfx::B2DVector(fOffsetX,fOffsetY),
 428                 nSteps,
 429                 fBorder,
 430                 fAngle);
 431         }
 432
 433         GeoTexSvxGradientSquare::~GeoTexSvxGradientSquare()
 434         {
 435         }
 436
 437         void GeoTexSvxGradientSquare::appendTransformationsAndColors(
 438             std::vector< B2DHomMatrixAndBColor >& rEntries,
 439             basegfx::BColor& rOuterColor)
 440         {
 441             rOuterColor = maStart;
 442
 443             if(maGradientInfo.getSteps())
 444             {
 445                 const double fStepSize(1.0 / maGradientInfo.getSteps());
 446                 B2DHomMatrixAndBColor aB2DHomMatrixAndBColor;
 447
 448                 for(sal_uInt32 a(1); a < maGradientInfo.getSteps(); a++)
 449                 {
 450                     const double fSize(1.0 - (fStepSize * a));
 451                     aB2DHomMatrixAndBColor.maB2DHomMatrix = maGradientInfo.getTextureTransform() * basegfx::tools::createScaleB2DHomMatrix(fSize, fSize);
 452                     aB2DHomMatrixAndBColor.maBColor = interpolate(maStart, maEnd, double(a) / double(maGradientInfo.getSteps() - 1));
 453                     rEntries.push_back(aB2DHomMatrixAndBColor);
 454                 }
 455             }
 456         }
 457
 458         void GeoTexSvxGradientSquare::modifyBColor(const basegfx::B2DPoint& rUV, basegfx::BColor& rBColor, double& /*rfOpacity*/) const
 459         {
 460             const double fScaler(basegfx::tools::getSquareGradientAlpha(rUV, maGradientInfo));
 461
 462             rBColor = basegfx::interpolate(maStart, maEnd, fScaler);
 463         }
 464     } // end of namespace texture
 465 } // end of namespace drawinglayer
 466
 467
 468 namespace drawinglayer
 469 {
 470     namespace texture
 471     {
 472         GeoTexSvxGradientRect::GeoTexSvxGradientRect(
 473             const basegfx::B2DRange& rDefinitionRange,
 474             const basegfx::BColor& rStart,
 475             const basegfx::BColor& rEnd,
 476             sal_uInt32 nSteps,
 477             double fBorder,
 478             double fOffsetX,
 479             double fOffsetY,
 480             double fAngle)
 481         :   GeoTexSvxGradient(rDefinitionRange, rStart, rEnd, nSteps, fBorder)
 482         {
 483             maGradientInfo = basegfx::tools::createRectangularODFGradientInfo(
 484                 rDefinitionRange,
 485                 basegfx::B2DVector(fOffsetX,fOffsetY),
 486                 nSteps,
 487                 fBorder,
 488                 fAngle);
 489         }
 490
 491         GeoTexSvxGradientRect::~GeoTexSvxGradientRect()
 492         {
 493         }
 494
 495         void GeoTexSvxGradientRect::appendTransformationsAndColors(
 496             std::vector< B2DHomMatrixAndBColor >& rEntries,
 497             basegfx::BColor& rOuterColor)
 498         {
 499             rOuterColor = maStart;
 500
 501             if(maGradientInfo.getSteps())
 502             {
 503                 double fWidth(1.0);
 504                 double fHeight(1.0);
 505                 double fIncrementX(0.0);
 506                 double fIncrementY(0.0);
 507
 508                 if(maGradientInfo.getAspectRatio() > 1.0)
 509                 {
 510                     fIncrementY = fHeight / maGradientInfo.getSteps();
 511                     fIncrementX = fIncrementY / maGradientInfo.getAspectRatio();
 512                 }
 513                 else
 514                 {
 515                     fIncrementX = fWidth / maGradientInfo.getSteps();
 516                     fIncrementY = fIncrementX * maGradientInfo.getAspectRatio();
 517                 }
 518
 519                 B2DHomMatrixAndBColor aB2DHomMatrixAndBColor;
 520
 521                 for(sal_uInt32 a(1); a < maGradientInfo.getSteps(); a++)
 522                 {
 523                     // next step
 524                     fWidth -= fIncrementX;
 525                     fHeight -= fIncrementY;
 526
 527                     aB2DHomMatrixAndBColor.maB2DHomMatrix = maGradientInfo.getTextureTransform() * basegfx::tools::createScaleB2DHomMatrix(fWidth, fHeight);
 528                     aB2DHomMatrixAndBColor.maBColor = interpolate(maStart, maEnd, double(a) / double(maGradientInfo.getSteps() - 1));
 529                     rEntries.push_back(aB2DHomMatrixAndBColor);
 530                 }
 531             }
 532         }
 533
 534         void GeoTexSvxGradientRect::modifyBColor(const basegfx::B2DPoint& rUV, basegfx::BColor& rBColor, double& /*rfOpacity*/) const
 535         {
 536             const double fScaler(basegfx::tools::getRectangularGradientAlpha(rUV, maGradientInfo));
 537
 538             rBColor = basegfx::interpolate(maStart, maEnd, fScaler);
 539         }
 540     } // end of namespace texture
 541 } // end of namespace drawinglayer
 542
 543
 544 namespace drawinglayer
 545 {
 546     namespace texture
 547     {
 548         GeoTexSvxHatch::GeoTexSvxHatch(
 549             const basegfx::B2DRange& rDefinitionRange,
 550             const basegfx::B2DRange& rOutputRange,
 551             double fDistance,
 552             double fAngle)
 553         :   maOutputRange(rOutputRange),
 554             maTextureTransform(),
 555             maBackTextureTransform(),
 556             mfDistance(0.1),
 557             mfAngle(fAngle),
 558             mnSteps(10),
 559             mbDefinitionRangeEqualsOutputRange(rDefinitionRange == rOutputRange)
 560         {
 561             double fTargetSizeX(rDefinitionRange.getWidth());
 562             double fTargetSizeY(rDefinitionRange.getHeight());
 563             double fTargetOffsetX(rDefinitionRange.getMinX());
 564             double fTargetOffsetY(rDefinitionRange.getMinY());
 565
 566             fAngle = -fAngle;
 567
 568             // add object expansion
 569             if(0.0 != fAngle)
 570             {
 571                 const double fAbsCos(fabs(cos(fAngle)));
 572                 const double fAbsSin(fabs(sin(fAngle)));
 573                 const double fNewX(fTargetSizeX * fAbsCos + fTargetSizeY * fAbsSin);
 574                 const double fNewY(fTargetSizeY * fAbsCos + fTargetSizeX * fAbsSin);
 575                 fTargetOffsetX -= (fNewX - fTargetSizeX) / 2.0;
 576                 fTargetOffsetY -= (fNewY - fTargetSizeY) / 2.0;
 577                 fTargetSizeX = fNewX;
 578                 fTargetSizeY = fNewY;
 579             }
 580
 581             // add object scale before rotate
 582             maTextureTransform.scale(fTargetSizeX, fTargetSizeY);
 583
 584             // add texture rotate after scale to keep perpendicular angles
 585             if(0.0 != fAngle)
 586             {
 587                 basegfx::B2DPoint aCenter(0.5, 0.5);
 588                 aCenter *= maTextureTransform;
 589
 590                 maTextureTransform = basegfx::tools::createRotateAroundPoint(aCenter, fAngle)
 591                     * maTextureTransform;
 592             }
 593
 594             // add object translate
 595             maTextureTransform.translate(fTargetOffsetX, fTargetOffsetY);
 596
 597             // prepare height for texture
 598             const double fSteps((0.0 != fDistance) ? fTargetSizeY / fDistance : 10.0);
 599             mnSteps = basegfx::fround(fSteps + 0.5);
 600             mfDistance = 1.0 / fSteps;
 601         }
 602
 603         GeoTexSvxHatch::~GeoTexSvxHatch()
 604         {
 605         }
 606
 607         bool GeoTexSvxHatch::operator==(const GeoTexSvx& rGeoTexSvx) const
 608         {
 609             const GeoTexSvxHatch* pCompare = dynamic_cast< const GeoTexSvxHatch* >(&rGeoTexSvx);
 610             return (pCompare
 611                 && maOutputRange == pCompare->maOutputRange
 612                 && maTextureTransform == pCompare->maTextureTransform
 613                 && mfDistance == pCompare->mfDistance
 614                 && mfAngle == pCompare->mfAngle
 615                 && mnSteps == pCompare->mnSteps);
 616         }
 617
 618         void GeoTexSvxHatch::appendTransformations(::std::vector< basegfx::B2DHomMatrix >& rMatrices)
 619         {
 620             if(mbDefinitionRangeEqualsOutputRange)
 621             {
 622                 // simple hatch where the definition area equals the output area
 623                 for(sal_uInt32 a(1); a < mnSteps; a++)
 624                 {
 625                     // create matrix
 626                     const double fOffset(mfDistance * (double)a);
 627                     basegfx::B2DHomMatrix aNew;
 628                     aNew.set(1, 2, fOffset);
 629                     rMatrices.push_back(maTextureTransform * aNew);
 630                 }
 631             }
 632             else
 633             {
 634                 // output area is different from definition area, back-transform to get
 635                 // the output area in unit coordinates and fill this with hatch lines
 636                 // using the settings derived from the definition area
 637                 basegfx::B2DRange aBackUnitRange(maOutputRange);
 638
 639                 aBackUnitRange.transform(getBackTextureTransform());
 640
 641                 // calculate vertical start value and a security maximum integer value to avoid death loops
 642                 double fStart(basegfx::snapToNearestMultiple(aBackUnitRange.getMinY(), mfDistance));
 643                 const sal_uInt32 nNeededIntegerSteps(basegfx::fround((aBackUnitRange.getHeight() / mfDistance) + 0.5));
 644                 sal_uInt32 nMaxIntegerSteps(::std::min(nNeededIntegerSteps, sal_uInt32(10000)));
 645
 646                 while(fStart < aBackUnitRange.getMaxY() && nMaxIntegerSteps)
 647                 {
 648                     // create new transform for
 649                     basegfx::B2DHomMatrix aNew;
 650
 651                     // adapt x scale and position
 652                     //aNew.scale(aBackUnitRange.getWidth(), 1.0);
 653                     //aNew.translate(aBackUnitRange.getMinX(), 0.0);
 654                     aNew.set(0, 0, aBackUnitRange.getWidth());
 655                     aNew.set(0, 2, aBackUnitRange.getMinX());
 656
 657                     // adapt y position to current step
 658                     aNew.set(1, 2, fStart);
 659                     //aNew.translate(0.0, fStart);
 660
 661                     // add new transformation
 662                     rMatrices.push_back(maTextureTransform * aNew);
 663
 664                     // next step
 665                     fStart += mfDistance;
 666                     nMaxIntegerSteps--;
 667                 }
 668             }
 669         }
 670
 671         double GeoTexSvxHatch::getDistanceToHatch(const basegfx::B2DPoint& rUV) const
 672         {
 673             const basegfx::B2DPoint aCoor(getBackTextureTransform() * rUV);
 674             return fmod(aCoor.getY(), mfDistance);
 675         }
 676
 677         const basegfx::B2DHomMatrix& GeoTexSvxHatch::getBackTextureTransform() const
 678         {
 679             if(maBackTextureTransform.isIdentity())
 680             {
 681                 const_cast< GeoTexSvxHatch* >(this)->maBackTextureTransform = maTextureTransform;
 682                 const_cast< GeoTexSvxHatch* >(this)->maBackTextureTransform.invert();
 683             }
 684
 685             return maBackTextureTransform;
 686         }
 687     } // end of namespace texture
 688 } // end of namespace drawinglayer
 689
 690
 691 namespace drawinglayer
 692 {
 693     namespace texture
 694     {
 695         GeoTexSvxTiled::GeoTexSvxTiled(
 696             const basegfx::B2DRange& rRange,
 697             double fOffsetX,
 698             double fOffsetY)
 699         :   maRange(rRange),
 700             mfOffsetX(basegfx::clamp(fOffsetX, 0.0, 1.0)),
 701             mfOffsetY(basegfx::clamp(fOffsetY, 0.0, 1.0))
 702         {
 703             if(!basegfx::fTools::equalZero(mfOffsetX))
 704             {
 705                 mfOffsetY = 0.0;
 706             }
 707         }
 708
 709         GeoTexSvxTiled::~GeoTexSvxTiled()
 710         {
 711         }
 712
 713         bool GeoTexSvxTiled::operator==(const GeoTexSvx& rGeoTexSvx) const
 714         {
 715             const GeoTexSvxTiled* pCompare = dynamic_cast< const GeoTexSvxTiled* >(&rGeoTexSvx);
 716
 717             return (pCompare
 718                 && maRange == pCompare->maRange
 719                 && mfOffsetX == pCompare->mfOffsetX
 720                 && mfOffsetY == pCompare->mfOffsetY);
 721         }
 722
 723         void GeoTexSvxTiled::appendTransformations(::std::vector< basegfx::B2DHomMatrix >& rMatrices)
 724         {
 725             const double fWidth(maRange.getWidth());
 726
 727             if(!basegfx::fTools::equalZero(fWidth))
 728             {
 729                 const double fHeight(maRange.getHeight());
 730
 731                 if(!basegfx::fTools::equalZero(fHeight))
 732                 {
 733                     double fStartX(maRange.getMinX());
 734                     double fStartY(maRange.getMinY());
 735                     sal_Int32 nPosX(0);
 736                     sal_Int32 nPosY(0);
 737
 738                     if(basegfx::fTools::more(fStartX, 0.0))
 739                     {
 740                         const sal_Int32 nDiff(static_cast<sal_Int32>(floor(fStartX / fWidth)) + 1);
 741
 742                         nPosX -= nDiff;
 743                         fStartX -= nDiff * fWidth;
 744                     }
 745
 746                     if(basegfx::fTools::less(fStartX + fWidth, 0.0))
 747                     {
 748                         const sal_Int32 nDiff(static_cast<sal_Int32>(floor(-fStartX / fWidth)));
 749
 750                         nPosX += nDiff;
 751                         fStartX += nDiff * fWidth;
 752                     }
 753
 754                     if(basegfx::fTools::more(fStartY, 0.0))
 755                     {
 756                         const sal_Int32 nDiff(static_cast<sal_Int32>(floor(fStartY / fHeight)) + 1);
 757
 758                         nPosY -= nDiff;
 759                         fStartY -= nDiff * fHeight;
 760                     }
 761
 762                     if(basegfx::fTools::less(fStartY + fHeight, 0.0))
 763                     {
 764                         const sal_Int32 nDiff(static_cast<sal_Int32>(floor(-fStartY / fHeight)));
 765
 766                         nPosY += nDiff;
 767                         fStartY += nDiff * fHeight;
 768                     }
 769
 770                     if(!basegfx::fTools::equalZero(mfOffsetY))
 771                     {
 772                         for(double fPosX(fStartX); basegfx::fTools::less(fPosX, 1.0); fPosX += fWidth, nPosX++)
 773                         {
 774                             for(double fPosY((nPosX % 2) ? fStartY - fHeight + (mfOffsetY * fHeight) : fStartY);
 775                                 basegfx::fTools::less(fPosY, 1.0); fPosY += fHeight)
 776                             {
 777                                 rMatrices.push_back(
 778                                     basegfx::tools::createScaleTranslateB2DHomMatrix(
 779                                         fWidth,
 780                                         fHeight,
 781                                         fPosX,
 782                                         fPosY));
 783                             }
 784                         }
 785                     }
 786                     else
 787                     {
 788                         for(double fPosY(fStartY); basegfx::fTools::less(fPosY, 1.0); fPosY += fHeight, nPosY++)
 789                         {
 790                             for(double fPosX((nPosY % 2) ? fStartX - fWidth + (mfOffsetX * fWidth) : fStartX);
 791                                 basegfx::fTools::less(fPosX, 1.0); fPosX += fWidth)
 792                             {
 793                                 rMatrices.push_back(
 794                                     basegfx::tools::createScaleTranslateB2DHomMatrix(
 795                                         fWidth,
 796                                         fHeight,
 797                                         fPosX,
 798                                         fPosY));
 799                             }
 800                         }
 801                     }
 802                 }
 803             }
 804         }
 805     } // end of namespace texture
 806 } // end of namespace drawinglayer
 807
 808 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */