drawinglayer/source/primitive3d/textureprimitive3d.cxx

   1 /*************************************************************************
   2  *
   3  *  OpenOffice.org - a multi-platform office productivity suite
   4  *
   5  *  $RCSfile: textureprimitive3d.cxx,v $
   6  *
   7  *  $Revision: 1.9 $
   8  *
   9  *  last change: $Author: aw $ $Date: 2008-06-10 09:29:33 $
  10  *
  11  *  The Contents of this file are made available subject to
  12  *  the terms of GNU Lesser General Public License Version 2.1.
  13  *
  14  *
  15  *    GNU Lesser General Public License Version 2.1
  16  *    =============================================
  17  *    Copyright 2005 by Sun Microsystems, Inc.
  18  *    901 San Antonio Road, Palo Alto, CA 94303, USA
  19  *
  20  *    This library is free software; you can redistribute it and/or
  21  *    modify it under the terms of the GNU Lesser General Public
  22  *    License version 2.1, as published by the Free Software Foundation.
  23  *
  24  *    This library is distributed in the hope that it will be useful,
  25  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  26  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  27  *    Lesser General Public License for more details.
  28  *
  29  *    You should have received a copy of the GNU Lesser General Public
  30  *    License along with this library; if not, write to the Free Software
  31  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  32  *    MA  02111-1307  USA
  33  *
  34  ************************************************************************/
  35
  36 // MARKER(update_precomp.py): autogen include statement, do not remove
  37 #include "precompiled_drawinglayer.hxx"
  38
  39 #include <drawinglayer/primitive3d/textureprimitive3d.hxx>
  40 #include <drawinglayer/primitive3d/drawinglayer_primitivetypes3d.hxx>
  41
  42 //////////////////////////////////////////////////////////////////////////////
  43
  44 using namespace com::sun::star;
  45
  46 //////////////////////////////////////////////////////////////////////////////
  47
  48 namespace drawinglayer
  49 {
  50     namespace primitive3d
  51     {
  52         TexturePrimitive3D::TexturePrimitive3D(
  53             const Primitive3DSequence& rChildren,
  54             const basegfx::B2DVector& rTextureSize,
  55             bool bModulate, bool bFilter)
  56         :       GroupPrimitive3D(rChildren),
  57             maTextureSize(rTextureSize),
  58             mbModulate(bModulate),
  59             mbFilter(bFilter)
  60         {
  61         }
  62
  63         bool TexturePrimitive3D::operator==(const BasePrimitive3D& rPrimitive) const
  64         {
  65             if(GroupPrimitive3D::operator==(rPrimitive))
  66             {
  67                 const TexturePrimitive3D& rCompare = (TexturePrimitive3D&)rPrimitive;
  68
  69                 return (getModulate() == rCompare.getModulate()
  70                     && getFilter() == rCompare.getFilter());
  71             }
  72
  73             return false;
  74         }
  75     } // end of namespace primitive3d
  76 } // end of namespace drawinglayer
  77
  78 //////////////////////////////////////////////////////////////////////////////
  79
  80 namespace drawinglayer
  81 {
  82     namespace primitive3d
  83     {
  84         Primitive3DSequence UnifiedAlphaTexturePrimitive3D::createLocalDecomposition(const geometry::ViewInformation3D& /*rViewInformation*/) const
  85         {
  86             if(0.0 == getTransparence())
  87             {
  88                 // no transparence used, so just use content
  89                 return getChildren();
  90             }
  91             else if(getTransparence() > 0.0 && getTransparence() < 1.0)
  92             {
  93                 // create AlphaTexturePrimitive3D with fixed transparence as replacement
  94                 const basegfx::BColor aGray(getTransparence(), getTransparence(), getTransparence());
  95                 const attribute::FillGradientAttribute aFillGradient(attribute::GRADIENTSTYLE_LINEAR, 0.0, 0.0, 0.0, 0.0, aGray, aGray, 1);
  96                 const Primitive3DReference xRef(new AlphaTexturePrimitive3D(aFillGradient, getChildren(), getTextureSize()));
  97                 return Primitive3DSequence(&xRef, 1L);
  98             }
  99             else
 100             {
 101                 // completely transparent or invalid definition, add nothing
 102                 return Primitive3DSequence();
 103             }
 104         }
 105
 106         UnifiedAlphaTexturePrimitive3D::UnifiedAlphaTexturePrimitive3D(
 107             double fTransparence,
 108             const Primitive3DSequence& rChildren)
 109         :       TexturePrimitive3D(rChildren, basegfx::B2DVector(), false, false),
 110             mfTransparence(fTransparence)
 111         {
 112         }
 113
 114         bool UnifiedAlphaTexturePrimitive3D::operator==(const BasePrimitive3D& rPrimitive) const
 115         {
 116             if(TexturePrimitive3D::operator==(rPrimitive))
 117             {
 118                 const UnifiedAlphaTexturePrimitive3D& rCompare = (UnifiedAlphaTexturePrimitive3D&)rPrimitive;
 119
 120                 return (getTransparence() == rCompare.getTransparence());
 121             }
 122
 123             return false;
 124         }
 125
 126         // provide unique ID
 127         ImplPrimitrive3DIDBlock(UnifiedAlphaTexturePrimitive3D, PRIMITIVE3D_ID_UNIFIEDALPHATEXTUREPRIMITIVE3D)
 128
 129     } // end of namespace primitive3d
 130 } // end of namespace drawinglayer
 131
 132 //////////////////////////////////////////////////////////////////////////////
 133
 134 namespace drawinglayer
 135 {
 136     namespace primitive3d
 137     {
 138         Primitive3DSequence GradientTexturePrimitive3D::createLocalDecomposition(const geometry::ViewInformation3D& /*rViewInformation*/) const
 139         {
 140             return getChildren();
 141         }
 142
 143         GradientTexturePrimitive3D::GradientTexturePrimitive3D(
 144             const attribute::FillGradientAttribute& rGradient,
 145             const Primitive3DSequence& rChildren,
 146             const basegfx::B2DVector& rTextureSize,
 147             bool bModulate,
 148             bool bFilter)
 149         :       TexturePrimitive3D(rChildren, rTextureSize, bModulate, bFilter),
 150             maGradient(rGradient)
 151         {
 152         }
 153
 154         bool GradientTexturePrimitive3D::operator==(const BasePrimitive3D& rPrimitive) const
 155         {
 156             if(TexturePrimitive3D::operator==(rPrimitive))
 157             {
 158                 const GradientTexturePrimitive3D& rCompare = (GradientTexturePrimitive3D&)rPrimitive;
 159
 160                 return (getGradient() == rCompare.getGradient());
 161             }
 162
 163             return false;
 164         }
 165
 166         // provide unique ID
 167         ImplPrimitrive3DIDBlock(GradientTexturePrimitive3D, PRIMITIVE3D_ID_GRADIENTTEXTUREPRIMITIVE3D)
 168
 169     } // end of namespace primitive3d
 170 } // end of namespace drawinglayer
 171
 172 //////////////////////////////////////////////////////////////////////////////
 173
 174 namespace drawinglayer
 175 {
 176     namespace primitive3d
 177     {
 178         Primitive3DSequence BitmapTexturePrimitive3D::createLocalDecomposition(const geometry::ViewInformation3D& /*rViewInformation*/) const
 179         {
 180             return getChildren();
 181         }
 182
 183         BitmapTexturePrimitive3D::BitmapTexturePrimitive3D(
 184             const attribute::FillBitmapAttribute& rBitmap,
 185             const Primitive3DSequence& rChildren,
 186             const basegfx::B2DVector& rTextureSize,
 187             bool bModulate, bool bFilter)
 188         :       TexturePrimitive3D(rChildren, rTextureSize, bModulate, bFilter),
 189             maBitmap(rBitmap)
 190         {
 191         }
 192
 193         bool BitmapTexturePrimitive3D::operator==(const BasePrimitive3D& rPrimitive) const
 194         {
 195             if(TexturePrimitive3D::operator==(rPrimitive))
 196             {
 197                 const BitmapTexturePrimitive3D& rCompare = (BitmapTexturePrimitive3D&)rPrimitive;
 198
 199                 return (getBitmap() == rCompare.getBitmap());
 200             }
 201
 202             return false;
 203         }
 204
 205         // provide unique ID
 206         ImplPrimitrive3DIDBlock(BitmapTexturePrimitive3D, PRIMITIVE3D_ID_BITMAPTEXTUREPRIMITIVE3D)
 207
 208     } // end of namespace primitive3d
 209 } // end of namespace drawinglayer
 210
 211 //////////////////////////////////////////////////////////////////////////////
 212
 213 namespace drawinglayer
 214 {
 215     namespace primitive3d
 216     {
 217         AlphaTexturePrimitive3D::AlphaTexturePrimitive3D(
 218             const attribute::FillGradientAttribute& rGradient,
 219             const Primitive3DSequence& rChildren,
 220             const basegfx::B2DVector& rTextureSize)
 221         :       GradientTexturePrimitive3D(rGradient, rChildren, rTextureSize, false, false)
 222         {
 223         }
 224
 225         bool AlphaTexturePrimitive3D::operator==(const BasePrimitive3D& rPrimitive) const
 226         {
 227             return (GradientTexturePrimitive3D::operator==(rPrimitive));
 228         }
 229
 230         // provide unique ID
 231         ImplPrimitrive3DIDBlock(AlphaTexturePrimitive3D, PRIMITIVE3D_ID_ALPHATEXTUREPRIMITIVE3D)
 232
 233     } // end of namespace primitive3d
 234 } // end of namespace drawinglayer
 235
 236 //////////////////////////////////////////////////////////////////////////////
 237 // eof