include/drawinglayer/primitive3d/textureprimitive3d.hxx

   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 #ifndef INCLUDED_DRAWINGLAYER_PRIMITIVE3D_TEXTUREPRIMITIVE3D_HXX
  21 #define INCLUDED_DRAWINGLAYER_PRIMITIVE3D_TEXTUREPRIMITIVE3D_HXX
  22
  23 #include <drawinglayer/drawinglayerdllapi.h>
  24
  25 #include <drawinglayer/primitive3d/groupprimitive3d.hxx>
  26 #include <drawinglayer/attribute/fillgraphicattribute.hxx>
  27 #include <basegfx/matrix/b2dhommatrix.hxx>
  28 #include <basegfx/vector/b2dvector.hxx>
  29 #include <drawinglayer/attribute/fillgradientattribute.hxx>
  30
  31
  32 namespace drawinglayer
  33 {
  34     namespace primitive3d
  35     {
  36         /** TexturePrimitive3D class
  37
  38             This 3D grouping primitive is used to define a texture for
  39             3d geometry by embedding it. It is used as bae class for
  40             extended texture definitions
  41          */
  42         class DRAWINGLAYER_DLLPUBLIC TexturePrimitive3D : public GroupPrimitive3D
  43         {
  44         private:
  45             /// texture geometry definition
  46             basegfx::B2DVector                          maTextureSize;
  47
  48             /// flag if texture shall be modulated with white interpolated color
  49             bool                                        mbModulate : 1;
  50
  51             /// flag if texture shall be filtered
  52             bool                                        mbFilter : 1;
  53
  54         public:
  55             /// constructor
  56             TexturePrimitive3D(
  57                 const Primitive3DContainer& rChildren,
  58                 const basegfx::B2DVector& rTextureSize,
  59                 bool bModulate,
  60                 bool bFilter);
  61
  62             /// data read access
  63             const basegfx::B2DVector& getTextureSize() const { return maTextureSize; }
  64             bool getModulate() const { return mbModulate; }
  65             bool getFilter() const { return mbFilter; }
  66
  67             /// compare operator
  68             virtual bool operator==(const BasePrimitive3D& rPrimitive) const override;
  69         };
  70     } // end of namespace primitive3d
  71 } // end of namespace drawinglayer
  72
  73
  74 namespace drawinglayer
  75 {
  76     namespace primitive3d
  77     {
  78         /** UnifiedTransparenceTexturePrimitive3D class
  79
  80             This 3D primitive expands TexturePrimitive3D to a unified
  81             transparence texture definition. All 3D primitives
  82             embedded here will be shown with the given transparency.
  83          */
  84         class DRAWINGLAYER_DLLPUBLIC UnifiedTransparenceTexturePrimitive3D : public TexturePrimitive3D
  85         {
  86         private:
  87             /// transparency definition
  88             double                                      mfTransparence;
  89
  90         public:
  91             /// constructor
  92             UnifiedTransparenceTexturePrimitive3D(
  93                 double fTransparence,
  94                 const Primitive3DContainer& rChildren);
  95
  96             /// data read access
  97             double getTransparence() const { return mfTransparence; }
  98
  99             /// compare operator
 100             virtual bool operator==(const BasePrimitive3D& rPrimitive) const override;
 101
 102             /// own getB3DRange implementation to include transparent geometries to BoundRect calculations
 103             virtual basegfx::B3DRange getB3DRange(const geometry::ViewInformation3D& rViewInformation) const override;
 104
 105             /// local decomposition.
 106             virtual Primitive3DContainer get3DDecomposition(const geometry::ViewInformation3D& rViewInformation) const override;
 107
 108             /// provide unique ID
 109             DeclPrimitive3DIDBlock()
 110         };
 111     } // end of namespace primitive3d
 112 } // end of namespace drawinglayer
 113
 114
 115 namespace drawinglayer
 116 {
 117     namespace primitive3d
 118     {
 119         /** GradientTexturePrimitive3D class
 120
 121             This 3D primitive expands TexturePrimitive3D to a gradient texture
 122             definition. All 3D primitives embedded here will be shown with the
 123             defined gradient.
 124          */
 125         class DRAWINGLAYER_DLLPUBLIC GradientTexturePrimitive3D : public TexturePrimitive3D
 126         {
 127         private:
 128             /// the gradient definition
 129             attribute::FillGradientAttribute        maGradient;
 130
 131         public:
 132             /// constructor
 133             GradientTexturePrimitive3D(
 134                 const attribute::FillGradientAttribute& rGradient,
 135                 const Primitive3DContainer& rChildren,
 136                 const basegfx::B2DVector& rTextureSize,
 137                 bool bModulate,
 138                 bool bFilter);
 139
 140             /// data read access
 141             const attribute::FillGradientAttribute& getGradient() const { return maGradient; }
 142
 143             /// compare operator
 144             virtual bool operator==(const BasePrimitive3D& rPrimitive) const override;
 145
 146             /// provide unique ID
 147             DeclPrimitive3DIDBlock()
 148         };
 149     } // end of namespace primitive3d
 150 } // end of namespace drawinglayer
 151
 152
 153 namespace drawinglayer
 154 {
 155     namespace primitive3d
 156     {
 157         /** BitmapTexturePrimitive3D class
 158
 159             This 3D primitive expands TexturePrimitive3D to a bitmap texture
 160             definition. All 3D primitives embedded here will be shown with the
 161             defined bitmap (maybe tiled if defined).
 162          */
 163         class DRAWINGLAYER_DLLPUBLIC BitmapTexturePrimitive3D : public TexturePrimitive3D
 164         {
 165         private:
 166             /// bitmap fill attribute
 167             attribute::FillGraphicAttribute     maFillGraphicAttribute;
 168
 169         public:
 170             /// constructor
 171             BitmapTexturePrimitive3D(
 172                 const attribute::FillGraphicAttribute& rFillGraphicAttribute,
 173                 const Primitive3DContainer& rChildren,
 174                 const basegfx::B2DVector& rTextureSize,
 175                 bool bModulate,
 176                 bool bFilter);
 177
 178             /// data read access
 179             const attribute::FillGraphicAttribute& getFillGraphicAttribute() const { return maFillGraphicAttribute; }
 180
 181             /// compare operator
 182             virtual bool operator==(const BasePrimitive3D& rPrimitive) const override;
 183
 184             /// provide unique ID
 185             DeclPrimitive3DIDBlock()
 186         };
 187     } // end of namespace primitive3d
 188 } // end of namespace drawinglayer
 189
 190
 191 namespace drawinglayer
 192 {
 193     namespace primitive3d
 194     {
 195         /** TransparenceTexturePrimitive3D class
 196
 197             This 3D primitive expands TexturePrimitive3D to a transparence texture
 198             definition. For transparence definition, a gradient is used. The values in
 199             that gradient will be interpreted as luminance Transparence-Values. All 3D
 200             primitives embedded here will be shown with the defined transparence.
 201          */
 202         class DRAWINGLAYER_DLLPUBLIC TransparenceTexturePrimitive3D : public GradientTexturePrimitive3D
 203         {
 204         public:
 205             /// constructor
 206             TransparenceTexturePrimitive3D(
 207                 const attribute::FillGradientAttribute& rGradient,
 208                 const Primitive3DContainer& rChildren,
 209                 const basegfx::B2DVector& rTextureSize);
 210
 211             /// compare operator
 212             virtual bool operator==(const BasePrimitive3D& rPrimitive) const override;
 213
 214             /// provide unique ID
 215             DeclPrimitive3DIDBlock()
 216         };
 217     } // end of namespace primitive3d
 218 } // end of namespace drawinglayer
 219
 220
 221 #endif //INCLUDED_DRAWINGLAYER_PRIMITIVE3D_TEXTUREPRIMITIVE3D_HXX
 222
 223 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */