drawinglayer/source/texture/texture3d.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/texture3d.hxx>
  21 #include <vcl/bitmapaccess.hxx>
  22 #include <drawinglayer/primitive3d/hatchtextureprimitive3d.hxx>
  23
  24
  25 namespace drawinglayer
  26 {
  27     namespace texture
  28     {
  29         GeoTexSvxMono::GeoTexSvxMono(
  30             const basegfx::BColor& rSingleColor,
  31             double fOpacity)
  32         :   maSingleColor(rSingleColor),
  33             mfOpacity(fOpacity)
  34         {
  35         }
  36
  37         bool GeoTexSvxMono::operator==(const GeoTexSvx& rGeoTexSvx) const
  38         {
  39             const GeoTexSvxMono* pCompare = dynamic_cast< const GeoTexSvxMono* >(&rGeoTexSvx);
  40
  41             return (pCompare
  42                 && maSingleColor == pCompare->maSingleColor
  43                 && mfOpacity == pCompare->mfOpacity);
  44         }
  45
  46         void GeoTexSvxMono::modifyBColor(const basegfx::B2DPoint& /*rUV*/, basegfx::BColor& rBColor, double& /*rfOpacity*/) const
  47         {
  48             rBColor = maSingleColor;
  49         }
  50
  51         void GeoTexSvxMono::modifyOpacity(const basegfx::B2DPoint& /*rUV*/, double& rfOpacity) const
  52         {
  53             rfOpacity = mfOpacity;
  54         }
  55     } // end of namespace texture
  56 } // end of namespace drawinglayer
  57
  58
  59 namespace drawinglayer
  60 {
  61     namespace texture
  62     {
  63         GeoTexSvxBitmapEx::GeoTexSvxBitmapEx(
  64             const BitmapEx& rBitmapEx,
  65             const basegfx::B2DRange& rRange)
  66         :   maBitmapEx(rBitmapEx),
  67             mpReadBitmap(nullptr),
  68             maTransparence(),
  69             mpReadTransparence(nullptr),
  70             maTopLeft(rRange.getMinimum()),
  71             maSize(rRange.getRange()),
  72             mfMulX(0.0),
  73             mfMulY(0.0),
  74             mbIsAlpha(false),
  75             mbIsTransparent(maBitmapEx.IsTransparent())
  76         {
  77             // #121194# Todo: use alpha channel, too (for 3d)
  78             mpReadBitmap = maBitmapEx.GetBitmap().AcquireReadAccess();
  79             OSL_ENSURE(mpReadBitmap, "GeoTexSvxBitmapEx: Got no read access to Bitmap (!)");
  80
  81             if(mbIsTransparent)
  82             {
  83                 if(maBitmapEx.IsAlpha())
  84                 {
  85                     mbIsAlpha = true;
  86                     maTransparence = rBitmapEx.GetAlpha().GetBitmap();
  87                 }
  88                 else
  89                 {
  90                     maTransparence = rBitmapEx.GetMask();
  91                 }
  92
  93                 mpReadTransparence = maTransparence.AcquireReadAccess();
  94             }
  95
  96             mfMulX = (double)mpReadBitmap->Width() / maSize.getX();
  97             mfMulY = (double)mpReadBitmap->Height() / maSize.getY();
  98
  99             if(maSize.getX() <= 1.0)
 100             {
 101                 maSize.setX(1.0);
 102             }
 103
 104             if(maSize.getY() <= 1.0)
 105             {
 106                 maSize.setY(1.0);
 107             }
 108         }
 109
 110         GeoTexSvxBitmapEx::~GeoTexSvxBitmapEx()
 111         {
 112             delete mpReadTransparence;
 113             delete mpReadBitmap;
 114         }
 115
 116         sal_uInt8 GeoTexSvxBitmapEx::impGetTransparence(sal_Int32& rX, sal_Int32& rY) const
 117         {
 118             switch(maBitmapEx.GetTransparentType())
 119             {
 120                 case TRANSPARENT_NONE:
 121                 {
 122                     break;
 123                 }
 124                 case TRANSPARENT_COLOR:
 125                 {
 126                     const BitmapColor aBitmapColor(mpReadBitmap->GetColor(rY, rX));
 127
 128                     if(maBitmapEx.GetTransparentColor() == aBitmapColor.operator Color())
 129                     {
 130                         return 255;
 131                     }
 132
 133                     break;
 134                 }
 135                 case TRANSPARENT_BITMAP:
 136                 {
 137                     OSL_ENSURE(mpReadTransparence, "OOps, transparence type Bitmap, but no read access created in the constructor (?)");
 138                     const BitmapColor aBitmapColor(mpReadTransparence->GetPixel(rY, rX));
 139
 140                     if(mbIsAlpha)
 141                     {
 142                         return aBitmapColor.GetIndex();
 143                     }
 144                     else
 145                     {
 146                         if(0x00 != aBitmapColor.GetIndex())
 147                         {
 148                             return 255;
 149                         }
 150                     }
 151                     break;
 152                 }
 153             }
 154
 155             return 0;
 156         }
 157
 158         bool GeoTexSvxBitmapEx::impIsValid(const basegfx::B2DPoint& rUV, sal_Int32& rX, sal_Int32& rY) const
 159         {
 160             if(mpReadBitmap)
 161             {
 162                 rX = (sal_Int32)((rUV.getX() - maTopLeft.getX()) * mfMulX);
 163
 164                 if(rX >= 0L && rX < mpReadBitmap->Width())
 165                 {
 166                     rY = (sal_Int32)((rUV.getY() - maTopLeft.getY()) * mfMulY);
 167
 168                     return (rY >= 0L && rY < mpReadBitmap->Height());
 169                 }
 170             }
 171
 172             return false;
 173         }
 174
 175         void GeoTexSvxBitmapEx::modifyBColor(const basegfx::B2DPoint& rUV, basegfx::BColor& rBColor, double& rfOpacity) const
 176         {
 177             sal_Int32 nX, nY;
 178
 179             if(impIsValid(rUV, nX, nY))
 180             {
 181                 const double fConvertColor(1.0 / 255.0);
 182                 const BitmapColor aBMCol(mpReadBitmap->GetColor(nY, nX));
 183                 const basegfx::BColor aBSource(
 184                     (double)aBMCol.GetRed() * fConvertColor,
 185                     (double)aBMCol.GetGreen() * fConvertColor,
 186                     (double)aBMCol.GetBlue() * fConvertColor);
 187
 188                 rBColor = aBSource;
 189
 190                 if(mbIsTransparent)
 191                 {
 192                     // when we have a transparence, make use of it
 193                     const sal_uInt8 aLuminance(impGetTransparence(nX, nY));
 194
 195                     rfOpacity = ((double)(0xff - aLuminance) * (1.0 / 255.0));
 196                 }
 197                 else
 198                 {
 199                     rfOpacity = 1.0;
 200                 }
 201             }
 202             else
 203             {
 204                 rfOpacity = 0.0;
 205             }
 206         }
 207
 208         void GeoTexSvxBitmapEx::modifyOpacity(const basegfx::B2DPoint& rUV, double& rfOpacity) const
 209         {
 210             sal_Int32 nX, nY;
 211
 212             if(impIsValid(rUV, nX, nY))
 213             {
 214                 if(mbIsTransparent)
 215                 {
 216                     // this texture has an alpha part, use it
 217                     const sal_uInt8 aLuminance(impGetTransparence(nX, nY));
 218                     const double fNewOpacity((double)(0xff - aLuminance) * (1.0 / 255.0));
 219
 220                     rfOpacity = 1.0 - ((1.0 - fNewOpacity) * (1.0 - rfOpacity));
 221                 }
 222                 else
 223                 {
 224                     // this texture is a color bitmap used as transparence map
 225                     const BitmapColor aBMCol(mpReadBitmap->GetColor(nY, nX));
 226                     const Color aColor(aBMCol.GetRed(), aBMCol.GetGreen(), aBMCol.GetBlue());
 227
 228                     rfOpacity = ((double)(0xff - aColor.GetLuminance()) * (1.0 / 255.0));
 229                 }
 230             }
 231             else
 232             {
 233                 rfOpacity = 0.0;
 234             }
 235         }
 236     } // end of namespace texture
 237 } // end of namespace drawinglayer
 238
 239
 240 namespace drawinglayer
 241 {
 242     namespace texture
 243     {
 244         basegfx::B2DPoint GeoTexSvxBitmapExTiled::impGetCorrected(const basegfx::B2DPoint& rUV) const
 245         {
 246             double fX(rUV.getX() - maTopLeft.getX());
 247             double fY(rUV.getY() - maTopLeft.getY());
 248
 249             if(mbUseOffsetX)
 250             {
 251                 const sal_Int32 nCol(static_cast< sal_Int32 >((fY < 0.0 ? maSize.getY() -fY : fY) / maSize.getY()));
 252
 253                 if(nCol % 2)
 254                 {
 255                     fX += mfOffsetX * maSize.getX();
 256                 }
 257             }
 258             else if(mbUseOffsetY)
 259             {
 260                 const sal_Int32 nRow(static_cast< sal_Int32 >((fX < 0.0 ? maSize.getX() -fX : fX) / maSize.getX()));
 261
 262                 if(nRow % 2)
 263                 {
 264                     fY += mfOffsetY * maSize.getY();
 265                 }
 266             }
 267
 268             fX = fmod(fX, maSize.getX());
 269             fY = fmod(fY, maSize.getY());
 270
 271             if(fX < 0.0)
 272             {
 273                 fX += maSize.getX();
 274             }
 275
 276             if(fY < 0.0)
 277             {
 278                 fY += maSize.getY();
 279             }
 280
 281             return basegfx::B2DPoint(fX + maTopLeft.getX(), fY + maTopLeft.getY());
 282         }
 283
 284         GeoTexSvxBitmapExTiled::GeoTexSvxBitmapExTiled(
 285             const BitmapEx& rBitmapEx,
 286             const basegfx::B2DRange& rRange,
 287             double fOffsetX,
 288             double fOffsetY)
 289         :   GeoTexSvxBitmapEx(rBitmapEx, rRange),
 290             mfOffsetX(basegfx::clamp(fOffsetX, 0.0, 1.0)),
 291             mfOffsetY(basegfx::clamp(fOffsetY, 0.0, 1.0)),
 292             mbUseOffsetX(!basegfx::fTools::equalZero(mfOffsetX)),
 293             mbUseOffsetY(!mbUseOffsetX && !basegfx::fTools::equalZero(mfOffsetY))
 294         {
 295         }
 296
 297         void GeoTexSvxBitmapExTiled::modifyBColor(const basegfx::B2DPoint& rUV, basegfx::BColor& rBColor, double& rfOpacity) const
 298         {
 299             if(mpReadBitmap)
 300             {
 301                 GeoTexSvxBitmapEx::modifyBColor(impGetCorrected(rUV), rBColor, rfOpacity);
 302             }
 303         }
 304
 305         void GeoTexSvxBitmapExTiled::modifyOpacity(const basegfx::B2DPoint& rUV, double& rfOpacity) const
 306         {
 307             if(mpReadBitmap)
 308             {
 309                 GeoTexSvxBitmapEx::modifyOpacity(impGetCorrected(rUV), rfOpacity);
 310             }
 311         }
 312     } // end of namespace texture
 313 } // end of namespace drawinglayer
 314
 315
 316 namespace drawinglayer
 317 {
 318     namespace texture
 319     {
 320         GeoTexSvxMultiHatch::GeoTexSvxMultiHatch(
 321             const primitive3d::HatchTexturePrimitive3D& rPrimitive,
 322             double fLogicPixelSize)
 323         :   mfLogicPixelSize(fLogicPixelSize),
 324             mp0(nullptr),
 325             mp1(nullptr),
 326             mp2(nullptr)
 327         {
 328             const attribute::FillHatchAttribute& rHatch(rPrimitive.getHatch());
 329             const basegfx::B2DRange aOutlineRange(0.0, 0.0, rPrimitive.getTextureSize().getX(), rPrimitive.getTextureSize().getY());
 330             const double fAngleA(rHatch.getAngle());
 331             maColor = rHatch.getColor();
 332             mbFillBackground = rHatch.isFillBackground();
 333             mp0 = new GeoTexSvxHatch(
 334                 aOutlineRange,
 335                 aOutlineRange,
 336                 rHatch.getDistance(),
 337                 fAngleA);
 338
 339             if(attribute::HatchStyle::Double == rHatch.getStyle() || attribute::HatchStyle::Triple == rHatch.getStyle())
 340             {
 341                 mp1 = new GeoTexSvxHatch(
 342                     aOutlineRange,
 343                     aOutlineRange,
 344                     rHatch.getDistance(),
 345                     fAngleA + F_PI2);
 346             }
 347
 348             if(attribute::HatchStyle::Triple == rHatch.getStyle())
 349             {
 350                 mp2 = new GeoTexSvxHatch(
 351                     aOutlineRange,
 352                     aOutlineRange,
 353                     rHatch.getDistance(),
 354                     fAngleA + F_PI4);
 355             }
 356         }
 357
 358         GeoTexSvxMultiHatch::~GeoTexSvxMultiHatch()
 359         {
 360             delete mp0;
 361             delete mp1;
 362             delete mp2;
 363         }
 364
 365         bool GeoTexSvxMultiHatch::impIsOnHatch(const basegfx::B2DPoint& rUV) const
 366         {
 367             if(mp0->getDistanceToHatch(rUV) < mfLogicPixelSize)
 368             {
 369                 return true;
 370             }
 371
 372             if(mp1 && mp1->getDistanceToHatch(rUV) < mfLogicPixelSize)
 373             {
 374                 return true;
 375             }
 376
 377             if(mp2 && mp2->getDistanceToHatch(rUV) < mfLogicPixelSize)
 378             {
 379                 return true;
 380             }
 381
 382             return false;
 383         }
 384
 385         void GeoTexSvxMultiHatch::modifyBColor(const basegfx::B2DPoint& rUV, basegfx::BColor& rBColor, double& rfOpacity) const
 386         {
 387             if(impIsOnHatch(rUV))
 388             {
 389                 rBColor = maColor;
 390             }
 391             else if(!mbFillBackground)
 392             {
 393                 rfOpacity = 0.0;
 394             }
 395         }
 396
 397         void GeoTexSvxMultiHatch::modifyOpacity(const basegfx::B2DPoint& rUV, double& rfOpacity) const
 398         {
 399             if(mbFillBackground || impIsOnHatch(rUV))
 400             {
 401                 rfOpacity = 1.0;
 402             }
 403             else
 404             {
 405                 rfOpacity = 0.0;
 406             }
 407         }
 408     } // end of namespace texture
 409 } // end of namespace drawinglayer
 410
 411 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */