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