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