drawinglayer/source/attribute/sdrattribute3d.cxx

   1 /*************************************************************************
   2  *
   3  *  OpenOffice.org - a multi-platform office productivity suite
   4  *
   5  *  $RCSfile: sdrattribute3d.cxx,v $
   6  *
   7  *  $Revision: 1.5 $
   8  *
   9  *  last change: $Author: aw $ $Date: 2008-05-27 14:11:19 $
  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/attribute/sdrattribute3d.hxx>
  40
  41 //////////////////////////////////////////////////////////////////////////////
  42
  43 namespace drawinglayer
  44 {
  45     namespace attribute
  46     {
  47         Sdr3DObjectAttribute::Sdr3DObjectAttribute(
  48             ::com::sun::star::drawing::NormalsKind      aNormalsKind,
  49             ::com::sun::star::drawing::TextureProjectionMode aTextureProjectionX,
  50             ::com::sun::star::drawing::TextureProjectionMode aTextureProjectionY,
  51             ::com::sun::star::drawing::TextureKind2 aTextureKind,
  52             ::com::sun::star::drawing::TextureMode aTextureMode,
  53             const MaterialAttribute3D& rMaterial,
  54             bool bNormalsInvert,
  55             bool bDoubleSided,
  56             bool bShadow3D,
  57             bool bTextureFilter,
  58             bool bReducedLineGeometry)
  59         :       maNormalsKind(aNormalsKind),
  60             maTextureProjectionX(aTextureProjectionX),
  61             maTextureProjectionY(aTextureProjectionY),
  62             maTextureKind(aTextureKind),
  63             maTextureMode(aTextureMode),
  64             maMaterial(rMaterial),
  65             mbNormalsInvert(bNormalsInvert),
  66             mbDoubleSided(bDoubleSided),
  67             mbShadow3D(bShadow3D),
  68             mbTextureFilter(bTextureFilter),
  69             mbReducedLineGeometry(bReducedLineGeometry)
  70         {
  71         }
  72
  73         bool Sdr3DObjectAttribute::operator==(const Sdr3DObjectAttribute& rCandidate) const
  74         {
  75             return (maNormalsKind == rCandidate.maNormalsKind
  76                 && maTextureProjectionX == rCandidate.maTextureProjectionX
  77                 && maTextureProjectionY == rCandidate.maTextureProjectionY
  78                 && maTextureKind == rCandidate.maTextureKind
  79                 && maTextureMode == rCandidate.maTextureMode
  80                 && maMaterial == rCandidate.maMaterial
  81                 && mbNormalsInvert == rCandidate.mbNormalsInvert
  82                 && mbDoubleSided == rCandidate.mbDoubleSided
  83                 && mbShadow3D == rCandidate.mbShadow3D
  84                 && mbTextureFilter == rCandidate.mbTextureFilter
  85                 && mbReducedLineGeometry == rCandidate.mbReducedLineGeometry);
  86         }
  87     } // end of namespace attribute
  88 } // end of namespace drawinglayer
  89
  90 //////////////////////////////////////////////////////////////////////////////
  91
  92 namespace drawinglayer
  93 {
  94     namespace attribute
  95     {
  96         Sdr3DLightAttribute::Sdr3DLightAttribute(const basegfx::BColor& rColor, const basegfx::B3DVector& rDirection, bool bSpecular)
  97         :       maColor(rColor),
  98             maDirection(rDirection),
  99             mbSpecular(bSpecular)
 100         {
 101         }
 102
 103         bool Sdr3DLightAttribute::operator==(const Sdr3DLightAttribute& rCandidate) const
 104         {
 105             return (maColor == rCandidate.maColor
 106                 && maDirection == rCandidate.maDirection
 107                 && mbSpecular == rCandidate.mbSpecular);
 108         }
 109     } // end of namespace attribute
 110 } // end of namespace drawinglayer
 111
 112 //////////////////////////////////////////////////////////////////////////////
 113
 114 namespace drawinglayer
 115 {
 116     namespace attribute
 117     {
 118         SdrLightingAttribute::SdrLightingAttribute(
 119             const basegfx::BColor& rAmbientLight,
 120             const ::std::vector< Sdr3DLightAttribute >& rLightVector)
 121         :       maAmbientLight(rAmbientLight),
 122             maLightVector(rLightVector)
 123         {
 124         }
 125
 126         bool SdrLightingAttribute::operator==(const SdrLightingAttribute& rCandidate) const
 127         {
 128             return (maAmbientLight == rCandidate.maAmbientLight
 129                 && maLightVector == rCandidate.maLightVector);
 130         }
 131
 132         // color model solver
 133         basegfx::BColor SdrLightingAttribute::solveColorModel(
 134             const basegfx::B3DVector& rNormalInEyeCoordinates,
 135             const basegfx::BColor& rColor, const basegfx::BColor& rSpecular,
 136             const basegfx::BColor& rEmission, sal_uInt16 nSpecularIntensity) const
 137         {
 138             // initialize with emissive color
 139             basegfx::BColor aRetval(rEmission);
 140
 141             // take care of global ambient light
 142             aRetval += getAmbientLight() * rColor;
 143
 144             // prepare light access. Is there a light?
 145             const sal_uInt32 nLightCount(maLightVector.size());
 146
 147             if(nLightCount && !rNormalInEyeCoordinates.equalZero())
 148             {
 149                 // prepare normal
 150                 basegfx::B3DVector aEyeNormal(rNormalInEyeCoordinates);
 151                 aEyeNormal.normalize();
 152
 153                 for(sal_uInt32 a(0L); a < nLightCount; a++)
 154                 {
 155                     const Sdr3DLightAttribute& rLight(maLightVector[a]);
 156                     const double fCosFac(rLight.getDirection().scalar(aEyeNormal));
 157
 158                     if(basegfx::fTools::more(fCosFac, 0.0))
 159                     {
 160                         aRetval += ((rLight.getColor() * rColor) * fCosFac);
 161
 162                         if(rLight.getSpecular())
 163                         {
 164                             // expand by (0.0, 0.0, 1.0) in Z
 165                             basegfx::B3DVector aSpecularNormal(rLight.getDirection().getX(), rLight.getDirection().getY(), rLight.getDirection().getZ() + 1.0);
 166                             aSpecularNormal.normalize();
 167                             double fCosFac2(aSpecularNormal.scalar(aEyeNormal));
 168
 169                             if(basegfx::fTools::more(fCosFac2, 0.0))
 170                             {
 171                                 fCosFac2 = pow(fCosFac2, (double)nSpecularIntensity);
 172                                 aRetval += (rSpecular * fCosFac2);
 173                             }
 174                         }
 175                     }
 176                 }
 177             }
 178
 179             // clamp to color space before usage
 180             aRetval.clamp();
 181
 182             return aRetval;
 183         }
 184     } // end of namespace attribute
 185 } // end of namespace drawinglayer
 186
 187 //////////////////////////////////////////////////////////////////////////////
 188
 189 namespace drawinglayer
 190 {
 191     namespace attribute
 192     {
 193         SdrSceneAttribute::SdrSceneAttribute(
 194             double fDistance,
 195             double fShadowSlant,
 196             ::com::sun::star::drawing::ProjectionMode aProjectionMode,
 197             ::com::sun::star::drawing::ShadeMode aShadeMode,
 198             bool bTwoSidedLighting)
 199         :       mfDistance(fDistance),
 200             mfShadowSlant(fShadowSlant),
 201             maProjectionMode(aProjectionMode),
 202             maShadeMode(aShadeMode),
 203             mbTwoSidedLighting(bTwoSidedLighting)
 204         {
 205         }
 206
 207         bool SdrSceneAttribute::operator==(const SdrSceneAttribute& rCandidate) const
 208         {
 209             return (mfDistance == rCandidate.mfDistance
 210                 && mfShadowSlant == rCandidate.mfShadowSlant
 211                 && maProjectionMode == rCandidate.maProjectionMode
 212                 && maShadeMode == rCandidate.maShadeMode
 213                 && mbTwoSidedLighting == rCandidate.mbTwoSidedLighting);
 214         }
 215     } // end of namespace attribute
 216 } // end of namespace drawinglayer
 217
 218 //////////////////////////////////////////////////////////////////////////////
 219 // eof