drawinglayer/source/geometry/viewinformation3d.cxx

   1 /*************************************************************************
   2  *
   3  *  OpenOffice.org - a multi-platform office productivity suite
   4  *
   5  *  $RCSfile: viewinformation3d.cxx,v $
   6  *
   7  *  $Revision: 1.2 $
   8  *
   9  *  last change: $Author: aw $ $Date: 2008-06-24 15:31:07 $
  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/geometry/viewinformation3d.hxx>
  40 #include <basegfx/range/b3drange.hxx>
  41 #include <basegfx/matrix/b3dhommatrix.hxx>
  42 #include <com/sun/star/geometry/AffineMatrix3D.hpp>
  43 #include <com/sun/star/geometry/RealRectangle3D.hpp>
  44 #include <basegfx/tools/canvastools.hxx>
  45
  46 //////////////////////////////////////////////////////////////////////////////
  47
  48 using namespace com::sun::star;
  49
  50 //////////////////////////////////////////////////////////////////////////////
  51
  52 namespace drawinglayer
  53 {
  54     namespace geometry
  55     {
  56         /** Implementation class for ViewInformation3D
  57         */
  58         class ImpViewInformation3D
  59         {
  60         private:
  61             // ViewInformation3D implementation can change refcount, so we have only
  62             // two memory regions for pairs of ViewInformation3D/ImpViewInformation3D
  63             friend class ::drawinglayer::geometry::ViewInformation3D;
  64
  65             // the refcounter. 0 means exclusively used
  66             sal_uInt32                                                                  mnRefCount;
  67
  68             // the 3D transformations
  69             // Object to World. This may change and being adapted when entering 3D transformation
  70             // groups
  71             basegfx::B3DHomMatrix                                               maObjectTransformation;
  72
  73             // World to Camera. This includes VRP, VPN and VUV camera coordinate system
  74             basegfx::B3DHomMatrix                                               maOrientation;
  75
  76             // Camera to Device with X,Y and Z [-1.0 .. 1.0]. This is the
  77             // 3D to 2D projection which may be parallell or perspective. When it is perspective,
  78             // the last line of the homogen matrix will NOT be unused
  79             basegfx::B3DHomMatrix                                               maProjection;
  80
  81             // Device to View with X,Y and Z [0.0 .. 1.0]. This converts from -1 to 1 coordinates
  82             // in camera coordinate system to 0 to 1 in unit 2D coordinates. This way it stays
  83             // view-independent. To get discrete coordinates, the 2D transformation of a scene
  84             // as 2D object needs to be involved
  85             basegfx::B3DHomMatrix                                               maDeviceToView;
  86
  87             // Object to View is the linear combination of all four transformations. It's
  88             // buffered to avoid too much matrix multiplying and created on demand
  89             basegfx::B3DHomMatrix                                               maObjectToView;
  90
  91             // the point in time
  92             double                                                                              mfViewTime;
  93
  94             // the complete PropertyValue representation (if already created)
  95             uno::Sequence< beans::PropertyValue >               mxViewInformation;
  96
  97             // the extra PropertyValues; does not contain the transformations
  98             uno::Sequence< beans::PropertyValue >               mxExtendedInformation;
  99
 100             // the local UNO API strings
 101             const ::rtl::OUString& getNamePropertyObjectTransformation()
 102             {
 103                 static ::rtl::OUString s_sNameProperty(RTL_CONSTASCII_USTRINGPARAM("ObjectTransformation"));
 104                 return s_sNameProperty;
 105             }
 106
 107             const ::rtl::OUString& getNamePropertyOrientation()
 108             {
 109                 static ::rtl::OUString s_sNameProperty(RTL_CONSTASCII_USTRINGPARAM("Orientation"));
 110                 return s_sNameProperty;
 111             }
 112
 113             const ::rtl::OUString& getNamePropertyProjection()
 114             {
 115                 static ::rtl::OUString s_sNameProperty(RTL_CONSTASCII_USTRINGPARAM("Projection"));
 116                 return s_sNameProperty;
 117             }
 118
 119             const ::rtl::OUString& getNamePropertyProjection_30()
 120             {
 121                 static ::rtl::OUString s_sNameProperty(RTL_CONSTASCII_USTRINGPARAM("Projection30"));
 122                 return s_sNameProperty;
 123             }
 124
 125             const ::rtl::OUString& getNamePropertyProjection_31()
 126             {
 127                 static ::rtl::OUString s_sNameProperty(RTL_CONSTASCII_USTRINGPARAM("Projection31"));
 128                 return s_sNameProperty;
 129             }
 130
 131             const ::rtl::OUString& getNamePropertyProjection_32()
 132             {
 133                 static ::rtl::OUString s_sNameProperty(RTL_CONSTASCII_USTRINGPARAM("Projection32"));
 134                 return s_sNameProperty;
 135             }
 136
 137             const ::rtl::OUString& getNamePropertyProjection_33()
 138             {
 139                 static ::rtl::OUString s_sNameProperty(RTL_CONSTASCII_USTRINGPARAM("Projection33"));
 140                 return s_sNameProperty;
 141             }
 142
 143             const ::rtl::OUString& getNamePropertyDeviceToView()
 144             {
 145                 static ::rtl::OUString s_sNameProperty(RTL_CONSTASCII_USTRINGPARAM("DeviceToView"));
 146                 return s_sNameProperty;
 147             }
 148
 149             const ::rtl::OUString& getNamePropertyTime()
 150             {
 151                 static ::rtl::OUString s_sNamePropertyTime(RTL_CONSTASCII_USTRINGPARAM("Time"));
 152                 return s_sNamePropertyTime;
 153             }
 154
 155             // a central PropertyValue parsing method to allow transportatin of
 156             // all ViewParameters using UNO API
 157             void impInterpretPropertyValues(const uno::Sequence< beans::PropertyValue >& rViewParameters)
 158             {
 159                 if(rViewParameters.hasElements())
 160                 {
 161                     const sal_Int32 nCount(rViewParameters.getLength());
 162                     sal_Int32 nExtendedInsert(0);
 163
 164                     // prepare extended information for filtering. Maximum size is nCount
 165                     mxExtendedInformation.realloc(nCount);
 166
 167                     for(sal_Int32 a(0); a < nCount; a++)
 168                     {
 169                         const beans::PropertyValue& rProp = rViewParameters[a];
 170
 171                         if(rProp.Name == getNamePropertyObjectTransformation())
 172                         {
 173                             com::sun::star::geometry::AffineMatrix3D aAffineMatrix3D;
 174                             rProp.Value >>= aAffineMatrix3D;
 175                             maObjectTransformation = basegfx::unotools::homMatrixFromAffineMatrix3D(aAffineMatrix3D);
 176                         }
 177                         else if(rProp.Name == getNamePropertyOrientation())
 178                         {
 179                             com::sun::star::geometry::AffineMatrix3D aAffineMatrix3D;
 180                             rProp.Value >>= aAffineMatrix3D;
 181                             maOrientation = basegfx::unotools::homMatrixFromAffineMatrix3D(aAffineMatrix3D);
 182                         }
 183                         else if(rProp.Name == getNamePropertyProjection())
 184                         {
 185                             // projection may be defined using a frustum in which case the last line of
 186                             // the 4x4 matrix is not (0,0,0,1). Since AffineMatrix3D does not support that,
 187                             // these four values need to be treated extra
 188                             const double f_30(maProjection.get(3, 0));
 189                             const double f_31(maProjection.get(3, 1));
 190                             const double f_32(maProjection.get(3, 2));
 191                             const double f_33(maProjection.get(3, 3));
 192
 193                             com::sun::star::geometry::AffineMatrix3D aAffineMatrix3D;
 194                             rProp.Value >>= aAffineMatrix3D;
 195                             maProjection = basegfx::unotools::homMatrixFromAffineMatrix3D(aAffineMatrix3D);
 196
 197                             maProjection.set(3, 0, f_30);
 198                             maProjection.set(3, 1, f_31);
 199                             maProjection.set(3, 2, f_32);
 200                             maProjection.set(3, 3, f_33);
 201                         }
 202                         else if(rProp.Name == getNamePropertyProjection_30())
 203                         {
 204                             double f_30(0.0);
 205                             rProp.Value >>= f_30;
 206                             maProjection.set(3, 0, f_30);
 207                         }
 208                         else if(rProp.Name == getNamePropertyProjection_31())
 209                         {
 210                             double f_31(0.0);
 211                             rProp.Value >>= f_31;
 212                             maProjection.set(3, 1, f_31);
 213                         }
 214                         else if(rProp.Name == getNamePropertyProjection_32())
 215                         {
 216                             double f_32(0.0);
 217                             rProp.Value >>= f_32;
 218                             maProjection.set(3, 2, f_32);
 219                         }
 220                         else if(rProp.Name == getNamePropertyProjection_33())
 221                         {
 222                             double f_33(1.0);
 223                             rProp.Value >>= f_33;
 224                             maProjection.set(3, 3, f_33);
 225                         }
 226                         else if(rProp.Name == getNamePropertyDeviceToView())
 227                         {
 228                             com::sun::star::geometry::AffineMatrix3D aAffineMatrix3D;
 229                             rProp.Value >>= aAffineMatrix3D;
 230                             maDeviceToView = basegfx::unotools::homMatrixFromAffineMatrix3D(aAffineMatrix3D);
 231                         }
 232                         else if(rProp.Name == getNamePropertyTime())
 233                         {
 234                             rProp.Value >>= mfViewTime;
 235                         }
 236                         else
 237                         {
 238                             // extra information; add to filtered information
 239                             mxExtendedInformation[nExtendedInsert++] = rProp;
 240                         }
 241                     }
 242
 243                     // extra information size is now known; realloc to final size
 244                     mxExtendedInformation.realloc(nExtendedInsert);
 245                 }
 246             }
 247
 248             // central method to create a Sequence of PropertyValues containing he complete
 249             // data set
 250             void impFillViewInformationFromContent()
 251             {
 252                 uno::Sequence< beans::PropertyValue > xRetval;
 253                 const bool bObjectTransformationUsed(!maObjectTransformation.isIdentity());
 254                 const bool bOrientationUsed(!maOrientation.isIdentity());
 255                 const bool bProjectionUsed(!maProjection.isIdentity());
 256                 const bool bDeviceToViewUsed(!maDeviceToView.isIdentity());
 257                 const bool bTimeUsed(0.0 < mfViewTime);
 258                 const bool bExtraInformation(mxExtendedInformation.hasElements());
 259
 260                 // projection may be defined using a frustum in which case the last line of
 261                 // the 4x4 matrix is not (0,0,0,1). Since AffineMatrix3D does not support that,
 262                 // these four values need to be treated extra
 263                 const bool bProjectionUsed_30(bProjectionUsed && !basegfx::fTools::equalZero(maProjection.get(3, 0)));
 264                 const bool bProjectionUsed_31(bProjectionUsed && !basegfx::fTools::equalZero(maProjection.get(3, 1)));
 265                 const bool bProjectionUsed_32(bProjectionUsed && !basegfx::fTools::equalZero(maProjection.get(3, 2)));
 266                 const bool bProjectionUsed_33(bProjectionUsed && !basegfx::fTools::equal(maProjection.get(3, 3), 1.0));
 267
 268                 sal_uInt32 nIndex(0);
 269                 const sal_uInt32 nCount(
 270                     (bObjectTransformationUsed ? 1 : 0) +
 271                     (bOrientationUsed ? 1 : 0) +
 272                     (bProjectionUsed ? 1 : 0) +
 273                     (bProjectionUsed_30 ? 1 : 0) +
 274                     (bProjectionUsed_31 ? 1 : 0) +
 275                     (bProjectionUsed_32 ? 1 : 0) +
 276                     (bProjectionUsed_33 ? 1 : 0) +
 277                     (bDeviceToViewUsed ? 1 : 0) +
 278                     (bTimeUsed ? 1 : 0) +
 279                     (bExtraInformation ? mxExtendedInformation.getLength() : 0));
 280
 281                 mxViewInformation.realloc(nCount);
 282
 283                 if(bObjectTransformationUsed)
 284                 {
 285                     com::sun::star::geometry::AffineMatrix3D aAffineMatrix3D;
 286                     basegfx::unotools::affineMatrixFromHomMatrix3D(aAffineMatrix3D, maObjectTransformation);
 287                     mxViewInformation[nIndex].Name = getNamePropertyObjectTransformation();
 288                     mxViewInformation[nIndex].Value <<= aAffineMatrix3D;
 289                     nIndex++;
 290                 }
 291
 292                 if(bOrientationUsed)
 293                 {
 294                     com::sun::star::geometry::AffineMatrix3D aAffineMatrix3D;
 295                     basegfx::unotools::affineMatrixFromHomMatrix3D(aAffineMatrix3D, maOrientation);
 296                     mxViewInformation[nIndex].Name = getNamePropertyOrientation();
 297                     mxViewInformation[nIndex].Value <<= aAffineMatrix3D;
 298                     nIndex++;
 299                 }
 300
 301                 if(bProjectionUsed)
 302                 {
 303                     com::sun::star::geometry::AffineMatrix3D aAffineMatrix3D;
 304                     basegfx::unotools::affineMatrixFromHomMatrix3D(aAffineMatrix3D, maProjection);
 305                     mxViewInformation[nIndex].Name = getNamePropertyProjection();
 306                     mxViewInformation[nIndex].Value <<= aAffineMatrix3D;
 307                     nIndex++;
 308                 }
 309
 310                 if(bProjectionUsed_30)
 311                 {
 312                     mxViewInformation[nIndex].Name = getNamePropertyProjection_30();
 313                     mxViewInformation[nIndex].Value <<= maProjection.get(3, 0);
 314                     nIndex++;
 315                 }
 316
 317                 if(bProjectionUsed_31)
 318                 {
 319                     mxViewInformation[nIndex].Name = getNamePropertyProjection_31();
 320                     mxViewInformation[nIndex].Value <<= maProjection.get(3, 1);
 321                     nIndex++;
 322                 }
 323
 324                 if(bProjectionUsed_32)
 325                 {
 326                     mxViewInformation[nIndex].Name = getNamePropertyProjection_32();
 327                     mxViewInformation[nIndex].Value <<= maProjection.get(3, 2);
 328                     nIndex++;
 329                 }
 330
 331                 if(bProjectionUsed_33)
 332                 {
 333                     mxViewInformation[nIndex].Name = getNamePropertyProjection_33();
 334                     mxViewInformation[nIndex].Value <<= maProjection.get(3, 3);
 335                     nIndex++;
 336                 }
 337
 338                 if(bDeviceToViewUsed)
 339                 {
 340                     com::sun::star::geometry::AffineMatrix3D aAffineMatrix3D;
 341                     basegfx::unotools::affineMatrixFromHomMatrix3D(aAffineMatrix3D, maDeviceToView);
 342                     mxViewInformation[nIndex].Name = getNamePropertyDeviceToView();
 343                     mxViewInformation[nIndex].Value <<= aAffineMatrix3D;
 344                     nIndex++;
 345                 }
 346
 347                 if(bTimeUsed)
 348                 {
 349                     mxViewInformation[nIndex].Name = getNamePropertyTime();
 350                     mxViewInformation[nIndex].Value <<= mfViewTime;
 351                     nIndex++;
 352                 }
 353
 354                 if(bExtraInformation)
 355                 {
 356                     const sal_Int32 nExtra(mxExtendedInformation.getLength());
 357
 358                     for(sal_Int32 a(0); a < nExtra; a++)
 359                     {
 360                         mxViewInformation[nIndex++] = mxExtendedInformation[a];
 361                     }
 362                 }
 363             }
 364
 365         public:
 366             ImpViewInformation3D(
 367                 const basegfx::B3DHomMatrix& rObjectTransformation,
 368                 const basegfx::B3DHomMatrix& rOrientation,
 369                 const basegfx::B3DHomMatrix& rProjection,
 370                 const basegfx::B3DHomMatrix& rDeviceToView,
 371                 double fViewTime,
 372                 const uno::Sequence< beans::PropertyValue >& rExtendedParameters)
 373             :   mnRefCount(0),
 374                 maObjectTransformation(rObjectTransformation),
 375                 maOrientation(rOrientation),
 376                 maProjection(rProjection),
 377                 maDeviceToView(rDeviceToView),
 378                 mfViewTime(fViewTime),
 379                 mxViewInformation(),
 380                 mxExtendedInformation()
 381             {
 382                 impInterpretPropertyValues(rExtendedParameters);
 383             }
 384
 385             ImpViewInformation3D(const uno::Sequence< beans::PropertyValue >& rViewParameters)
 386             :   mnRefCount(0),
 387                 maObjectTransformation(),
 388                 maOrientation(),
 389                 maProjection(),
 390                 maDeviceToView(),
 391                 mfViewTime(),
 392                 mxViewInformation(rViewParameters),
 393                 mxExtendedInformation()
 394             {
 395                 impInterpretPropertyValues(rViewParameters);
 396             }
 397
 398             const basegfx::B3DHomMatrix& getObjectTransformation() const { return maObjectTransformation; }
 399             const basegfx::B3DHomMatrix& getOrientation() const { return maOrientation; }
 400             const basegfx::B3DHomMatrix& getProjection() const { return maProjection; }
 401             const basegfx::B3DHomMatrix& getDeviceToView() const { return maDeviceToView; }
 402             double getViewTime() const { return mfViewTime; }
 403
 404             const basegfx::B3DHomMatrix& getObjectToView() const
 405             {
 406                 // on demand WorldToView creation
 407                 ::osl::Mutex m_mutex;
 408
 409                 if(maObjectToView.isIdentity())
 410                 {
 411                     const_cast< ImpViewInformation3D* >(this)->maObjectToView = maDeviceToView * maProjection * maOrientation * maObjectTransformation;
 412                 }
 413
 414                 return maObjectToView;
 415             }
 416
 417             const uno::Sequence< beans::PropertyValue >& getViewInformationSequence() const
 418             {
 419                 ::osl::Mutex m_mutex;
 420
 421                 if(!mxViewInformation.hasElements())
 422                 {
 423                     const_cast< ImpViewInformation3D* >(this)->impFillViewInformationFromContent();
 424                 }
 425
 426                 return mxViewInformation;
 427             }
 428
 429             const uno::Sequence< beans::PropertyValue >& getExtendedInformationSequence() const
 430             {
 431                 return mxExtendedInformation;
 432             }
 433
 434             bool operator==(const ImpViewInformation3D& rCandidate) const
 435             {
 436                 return (maObjectTransformation == rCandidate.maObjectTransformation
 437                     && maOrientation == rCandidate.maOrientation
 438                     && maProjection == rCandidate.maProjection
 439                     && maDeviceToView == rCandidate.maDeviceToView
 440                     && mfViewTime == rCandidate.mfViewTime
 441                     && mxExtendedInformation == rCandidate.mxExtendedInformation);
 442             }
 443         };
 444     } // end of anonymous namespace
 445 } // end of namespace drawinglayer
 446
 447 //////////////////////////////////////////////////////////////////////////////
 448
 449 namespace drawinglayer
 450 {
 451     namespace geometry
 452     {
 453         ViewInformation3D::ViewInformation3D(
 454             const basegfx::B3DHomMatrix& rObjectObjectTransformation,
 455             const basegfx::B3DHomMatrix& rOrientation,
 456             const basegfx::B3DHomMatrix& rProjection,
 457             const basegfx::B3DHomMatrix& rDeviceToView,
 458             double fViewTime,
 459             const uno::Sequence< beans::PropertyValue >& rExtendedParameters)
 460         :       mpViewInformation3D(new ImpViewInformation3D(rObjectObjectTransformation, rOrientation, rProjection, rDeviceToView, fViewTime, rExtendedParameters))
 461         {
 462         }
 463
 464         ViewInformation3D::ViewInformation3D(const uno::Sequence< beans::PropertyValue >& rViewParameters)
 465         :       mpViewInformation3D(new ImpViewInformation3D(rViewParameters))
 466         {
 467         }
 468
 469         ViewInformation3D::ViewInformation3D(const ViewInformation3D& rCandidate)
 470         :       mpViewInformation3D(rCandidate.mpViewInformation3D)
 471         {
 472             ::osl::Mutex m_mutex;
 473             mpViewInformation3D->mnRefCount++;
 474         }
 475
 476         ViewInformation3D::~ViewInformation3D()
 477         {
 478             ::osl::Mutex m_mutex;
 479
 480             if(mpViewInformation3D->mnRefCount)
 481             {
 482                 mpViewInformation3D->mnRefCount--;
 483             }
 484             else
 485             {
 486                 delete mpViewInformation3D;
 487             }
 488         }
 489
 490         ViewInformation3D& ViewInformation3D::operator=(const ViewInformation3D& rCandidate)
 491         {
 492             ::osl::Mutex m_mutex;
 493
 494             if(mpViewInformation3D->mnRefCount)
 495             {
 496                 mpViewInformation3D->mnRefCount--;
 497             }
 498             else
 499             {
 500                 delete mpViewInformation3D;
 501             }
 502
 503             mpViewInformation3D = rCandidate.mpViewInformation3D;
 504             mpViewInformation3D->mnRefCount++;
 505
 506             return *this;
 507         }
 508
 509         bool ViewInformation3D::operator==(const ViewInformation3D& rCandidate) const
 510         {
 511             if(rCandidate.mpViewInformation3D == mpViewInformation3D)
 512             {
 513                 return true;
 514             }
 515
 516             return (*rCandidate.mpViewInformation3D == *mpViewInformation3D);
 517         }
 518
 519         const basegfx::B3DHomMatrix& ViewInformation3D::getObjectTransformation() const
 520         {
 521             return mpViewInformation3D->getObjectTransformation();
 522         }
 523
 524         const basegfx::B3DHomMatrix& ViewInformation3D::getOrientation() const
 525         {
 526             return mpViewInformation3D->getOrientation();
 527         }
 528
 529         const basegfx::B3DHomMatrix& ViewInformation3D::getProjection() const
 530         {
 531             return mpViewInformation3D->getProjection();
 532         }
 533
 534         const basegfx::B3DHomMatrix& ViewInformation3D::getDeviceToView() const
 535         {
 536             return mpViewInformation3D->getDeviceToView();
 537         }
 538
 539         const basegfx::B3DHomMatrix& ViewInformation3D::getObjectToView() const
 540         {
 541             return mpViewInformation3D->getObjectToView();
 542         }
 543
 544         double ViewInformation3D::getViewTime() const
 545         {
 546             return mpViewInformation3D->getViewTime();
 547         }
 548
 549         const uno::Sequence< beans::PropertyValue >& ViewInformation3D::getViewInformationSequence() const
 550         {
 551             return mpViewInformation3D->getViewInformationSequence();
 552         }
 553
 554         const uno::Sequence< beans::PropertyValue >& ViewInformation3D::getExtendedInformationSequence() const
 555         {
 556             return mpViewInformation3D->getExtendedInformationSequence();
 557         }
 558     } // end of namespace geometry
 559 } // end of namespace drawinglayer
 560
 561 //////////////////////////////////////////////////////////////////////////////
 562 // eof