binfilter/inc/bf_svx/obj3d.hxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: obj3d.hxx,v $
  10  * $Revision: 1.8 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 #ifndef _E3D_OBJ3D_HXX
  32 #define _E3D_OBJ3D_HXX
  33
  34 #ifndef _SVDOATTR_HXX //autogen
  35 #include <bf_svx/svdoattr.hxx>
  36 #endif
  37
  38 #ifndef _SVDOBJ_HXX //autogen
  39 #include <bf_svx/svdobj.hxx>
  40 #endif
  41
  42 #ifndef _VOLUME3D_HXX
  43 #include <bf_svx/volume3d.hxx>
  44 #endif
  45
  46 #ifndef _SVX_MATRIX3D_HXX
  47 #include <bf_svx/matrix3d.hxx>
  48 #endif
  49
  50 #ifndef _DEF3D_HXX
  51 #include <bf_svx/def3d.hxx>
  52 #endif
  53
  54 #ifndef _SVDPAGE_HXX
  55 #include <bf_svx/svdpage.hxx>
  56 #endif
  57
  58 #ifndef _E3D_DEFLT3D_HXX
  59 #include <bf_svx/deflt3d.hxx>
  60 #endif
  61
  62 #ifndef _SV_BITMAP_HXX
  63 #include <vcl/bitmap.hxx>
  64 #endif
  65
  66 #ifndef _B3D_B3DGEOM_HXX
  67 #include <bf_goodies/b3dgeom.hxx>
  68 #endif
  69
  70 #ifndef _B3D_MATRIL3D_HXX
  71 #include <bf_goodies/matril3d.hxx>
  72 #endif
  73
  74 #ifndef _B3D_B3DTEX_HXX
  75 #include <bf_goodies/b3dtex.hxx>
  76 #endif
  77
  78 #ifndef _B3D_B3DLIGHT_HXX
  79 #include <bf_goodies/b3dlight.hxx>
  80 #endif
  81
  82 #ifndef _B3D_BASE3D_HXX
  83 #include <bf_goodies/base3d.hxx>
  84 #endif
  85
  86 #ifndef _SVX3DITEMS_HXX
  87 #include <bf_svx/svx3ditems.hxx>
  88 #endif
  89
  90 #ifndef _SVX_XFLCLIT_HXX
  91 #include <bf_svx/xflclit.hxx>
  92 #endif
  93 class Base3D;
  94 namespace binfilter {
  95 class SfxPoolItem;
  96
  97 //************************************************************
  98 //   Vorausdeklarationen
  99 //************************************************************
 100
 101 class Viewport3D;
 102 class E3dLightList;
 103 class E3dScene;
 104 class E3dPolyScene;
 105 class PolyPolygon3D;
 106
 107 /*************************************************************************
 108 |*
 109 |* Defines fuer nDrawFlag in Paint3D
 110 |*
 111 \************************************************************************/
 112
 113 #define E3D_DRAWFLAG_FILLED                                             0x0001
 114 #define E3D_DRAWFLAG_OUTLINE                                    0x0002
 115 #define E3D_DRAWFLAG_TRANSPARENT                                0x0004
 116 #define E3D_DRAWFLAG_GHOSTED                                    0x0008
 117
 118 /*************************************************************************
 119 |*
 120 |* GeoData relevant fuer Undo-Actions
 121 |*
 122 \************************************************************************/
 123
 124 class E3DObjGeoData : public SdrObjGeoData
 125 {
 126 public:
 127     Volume3D                                    aLocalBoundVol;         // umschliessendes Volumen des Objekts
 128     Matrix4D                                    aTfMatrix;                      // lokale Transformation
 129
 130     E3DObjGeoData() {}
 131 };
 132
 133 /*************************************************************************
 134 |*
 135 |* Liste fuer 3D-Objekte
 136 |*
 137 \************************************************************************/
 138
 139 class E3dObjList : public SdrObjList
 140 {
 141 public:
 142     TYPEINFO();
 143     E3dObjList(SdrModel* pNewModel, SdrPage* pNewPage, E3dObjList* pNewUpList=NULL);
 144     E3dObjList(const E3dObjList& rSrcList);
 145     virtual ~E3dObjList();
 146
 147     virtual void NbcInsertObject(SdrObject* pObj, ULONG nPos=CONTAINER_APPEND,
 148         const SdrInsertReason* pReason=NULL);
 149     virtual SdrObject* RemoveObject(ULONG nObjNum);
 150 };
 151
 152 /*************************************************************************
 153 |*
 154 |* Basisklasse fuer 3D-Objekte
 155 |*
 156 \************************************************************************/
 157
 158 class E3dObject : public SdrAttrObj
 159 {
 160     // Aus der E3dObjList und E3dDragMethod alles erlauben
 161     friend class E3dObjList;
 162     friend class E3dDragMethod;
 163
 164  protected:
 165     E3dObjList*         pSub;                           // Subliste (Childobjekte)
 166
 167     Volume3D            aBoundVol;                      // umschliessendes Volumen mit allen Childs
 168     Volume3D            aLocalBoundVol;         // umschliessendes Volumen des Objekts
 169     Matrix4D            aTfMatrix;                      // lokale Transformation
 170     Matrix4D            aFullTfMatrix;          // globale Transformation (inkl. Parents)
 171
 172     UINT16                      nLogicalGroup;          // logische Gruppe fuer StarChart
 173     UINT16                      nObjTreeLevel;          // Ebene in der Objekt-Hierarchie
 174     UINT16                      nPartOfParent;          // Objekt ist (Bau-)Teil des Parents,
 175                                         // wenn ungleich 0; kann objektspezifische
 176                                         // Codewerte enthalten
 177     E3dDragDetail       eDragDetail;            // Detailstufe fuer Wireframes
 178
 179     // Flags
 180     unsigned            bTfHasChanged                   : 1;
 181     unsigned            bBoundVolValid                  : 1;
 182     unsigned            bIsSelected                             : 1;
 183
 184  public:
 185     virtual void SetBoundVolInvalid();
 186
 187  protected:
 188     virtual void SetTransformChanged();
 189     virtual void NewObjectInserted(const E3dObject* p3DObj);
 190     virtual void StructureChanged(const E3dObject* p3DObj);
 191     virtual void ForceDefaultAttr();
 192     virtual void RecalcBoundVolume();
 193
 194     BOOL    ImpCheckSubRecords (const SdrObjIOHeader& rHead,
 195                                 SvStream&             rIn);
 196     void        SetObjTreeLevel(USHORT nNewLevel);
 197
 198     // Wie in SdrAttrObj:
 199     SfxItemPool* ImpGetItemPool(const SfxPoolItem* pAlternateItem1,
 200                                 const SfxPoolItem* pAlternateItem2) const;
 201     SfxItemPool* ImpGetItemPool() const;
 202     const SfxPoolItem* ImpSetNewAttr(const SfxPoolItem* pAkt,
 203                                      const SfxPoolItem* pNew,
 204                                      FASTBOOL bChg = TRUE);
 205
 206  public:
 207     TYPEINFO();
 208     E3dObject();
 209     E3dObject(BOOL bIsFromChart);
 210
 211     virtual void RecalcSnapRect();
 212     virtual void RecalcBoundRect();
 213     virtual void SetRectsDirty(FASTBOOL bNotMyself=FALSE);
 214
 215     virtual ~E3dObject();
 216
 217     virtual UINT32      GetObjInventor() const;
 218     virtual UINT16      GetObjIdentifier() const;
 219
 220
 221     virtual SdrLayerID  GetLayer() const;
 222     virtual void                NbcSetLayer(SdrLayerID nLayer);
 223
 224     virtual void                SetObjList(SdrObjList* pNewObjList);
 225     virtual void                SetPage(SdrPage* pNewPage);
 226     virtual void                SetModel(SdrModel* pNewModel);
 227 /*N*/   virtual void NbcResize(const Point& rRef, const Fraction& xFact, const Fraction& yFact);
 228
 229     virtual SdrObjList* GetSubList() const;
 230
 231
 232     // 3D-Zeichenmethode
 233
 234     // Objekt als Kontur in das Polygon einfuegen
 235
 236     // Schatten fuer 3D-Objekte zeichnen
 237
 238     // 3D-Objekt in die Gruppe einfuegen; Eigentumsuebergang!
 239     virtual void Insert3DObj(E3dObject* p3DObj);
 240     void Remove3DObj(E3dObject* p3DObj);
 241
 242     E3dObject* GetParentObj() const;
 243     virtual E3dScene* GetScene() const;
 244
 245     const Volume3D& GetLocalBoundVolume() { return aLocalBoundVol; }
 246     virtual const Volume3D& GetBoundVolume();
 247     Vector3D GetCenter();
 248
 249     // komplette Transformation inklusive aller Parents berechnen
 250     virtual const Matrix4D& GetFullTransform();
 251
 252     // Transformationsmatrix abfragen bzw. (zurueck)setzen
 253     virtual const Matrix4D& GetTransform() const;
 254     virtual void NbcSetTransform(const Matrix4D& rMatrix);
 255     virtual void NbcResetTransform();
 256     virtual void SetTransform(const Matrix4D& rMatrix);
 257
 258     // Translation
 259     // Skalierung
 260
 261
 262     // Rotation mit Winkel in Radiant
 263
 264
 265     // [FG] 2D-Rotationen, werden hier als Rotationen um die Z-Achse, die in den Bildschirm zeigt,
 266     //      implementiert plus eine Verschiebung der Scene. Dies bedeutet auch die Scene (E3dScene)
 267     //      muss diese Routine in der Klasse als virtual definieren.
 268
 269     // Transformation auf die Koordinaten (nicht auf die lokale Matrix)
 270     // eines Objekts und seiner Childs anwenden; Objekte, die eigene
 271     // Koordinaten speichern, muessen diese Methode implementieren
 272     // Wireframe-Darstellung des Objekts erzeugen und die Linien als
 273     // Punkt-Paare in rPoly3D ablegen
 274
 275     // TakeObjName...() ist fuer die Anzeige in der UI, z.B. "3 Rahmen selektiert".
 276
 277     USHORT GetObjTreeLevel() const { return nObjTreeLevel; }
 278
 279     FASTBOOL HasLogicalGroup() { return ( nLogicalGroup > 0 ); }
 280     USHORT GetLogicalGroup() { return nLogicalGroup; }
 281
 282     void SetDragDetail(E3dDragDetail eDetail)   { eDragDetail = eDetail; }
 283     E3dDragDetail GetDragDetail()                               { return eDragDetail; }
 284
 285     void        SetPartOfParent(UINT16 nPartCode = 1) { nPartOfParent = nPartCode; }
 286     UINT16      GetPartCode()   { return nPartOfParent; }
 287     FASTBOOL IsPartOfParent() const { return (nPartOfParent != 0); }
 288
 289
 290     // ItemSet access
 291     virtual const SfxItemSet& GetItemSet() const;
 292     virtual SfxItemSet* CreateNewItemSet(SfxItemPool& rPool);
 293
 294     // private support routines for ItemSet access. NULL pointer means clear item.
 295     virtual void ItemChange(const sal_uInt16 nWhich, const SfxPoolItem* pNewItem = 0);
 296
 297     // #107770# PostItemChange support is necessary here to support the same propagating
 298     // of scene items like it is done in ItemChange() for E3dObject.
 299     virtual void PostItemChange(const sal_uInt16 nWhich);
 300
 301     virtual void ItemSetChanged(const SfxItemSet& rSet);
 302
 303     virtual void NbcSetStyleSheet(SfxStyleSheet* pNewStyleSheet, FASTBOOL bDontRemoveHardAttr);
 304
 305     virtual void WriteData(SvStream& rOut) const;
 306     virtual void ReadData(const SdrObjIOHeader& rHead, SvStream& rIn);
 307     virtual void AfterRead();
 308
 309     virtual SdrObjGeoData *NewGeoData() const;
 310     virtual void          SaveGeoData(SdrObjGeoData& rGeo) const;
 311     virtual void          RestGeoData(const SdrObjGeoData& rGeo);
 312
 313     // diese Funktionen schreiben nur die Member von E3dObject wird auch von E3dSphere
 314     // gerufen.
 315     void ReadOnlyOwnMembers(const SdrObjIOHeader& rHead, SvStream& rIn);
 316     void WriteOnlyOwnMembers(SvStream& rOut) const;
 317
 318     // Selektion Setzen/Lesen
 319     BOOL GetSelected() { return bIsSelected; }
 320
 321     // Aufbrechen
 322     virtual SdrAttrObj* GetBreakObj();
 323 };
 324
 325 /*************************************************************************
 326 |*
 327 |* Klasse fuer alle zusammengesetzen Objekte (Cube, Lathe, Scene, Extrude)
 328 |* Diese Klasse erspart ein paar ISA-Abfragen und sie beschleunigt das
 329 |* Verhalten ungemein, da alle Attribute usw. fuer die untergeordneten
 330 |* Polygone hierueber gehalten werden. Die Polygone duerfen nur Attribute
 331 |* halten, wenn sie direkt einer Szene untergeordnet sind.
 332 |*
 333 \************************************************************************/
 334
 335 class E3dCompoundObject : public E3dObject
 336 {
 337     virtual void ForceDefaultAttr();
 338
 339 protected:
 340     // Die Darstellungsgeometrie dieses Objektes
 341     B3dGeometry                         aDisplayGeometry;
 342
 343     // Material des Objektes
 344     Color                                       aMaterialAmbientColor;
 345     B3dMaterial                         aBackMaterial;
 346
 347     // Attribute zur Geometrieerzeugung
 348     unsigned                            bCreateNormals                          : 1;
 349     unsigned                            bCreateTexture                          : 1;
 350
 351     // Wird zwischen Vorder- und Hintergrundmaterial unterschieden
 352     unsigned                            bUseDifferentBackMaterial       : 1;
 353
 354     // Attribut zum Datei lesen altes format
 355     unsigned                            bBytesLeft                                      : 1;
 356
 357     // Switch, ob bei Geometrieerzeugung E3dPolyObj's erzeugt
 358     // werden sollen (z.B. zum speichern)
 359     unsigned                            bCreateE3dPolyObj                       : 1;
 360
 361     // Geometrie gueltig?
 362     unsigned                            bGeometryValid                          : 1;
 363
 364 protected:
 365     // Hilfsfunktionen zur Geometrieerzeugung
 366     void GrowPoly(
 367         PolyPolygon3D& rPolyPolyGrow,
 368         PolyPolygon3D& rPolyPolyNormals,
 369         double fFactor);
 370
 371     void RotatePoly(
 372         PolyPolygon3D& rPolyPolyRotate,
 373         Matrix4D& rRotMat);
 374
 375     void ScalePoly(
 376         PolyPolygon3D& rPolyPolyScale,
 377         double fFactor);
 378
 379
 380     void CreateFront(
 381         const PolyPolygon3D& rPolyPoly3D,
 382         const PolyPolygon3D& rFrontNormals,
 383         BOOL bCreateNormals = TRUE,
 384         BOOL bCreateTexture = TRUE);
 385     void AddFrontNormals(
 386         const PolyPolygon3D& rPolyPoly3D,
 387         PolyPolygon3D& rNormalsFront,
 388         Vector3D& rOffset);
 389
 390     void CreateBack(
 391         const PolyPolygon3D& rPolyPoly3D,
 392         const PolyPolygon3D& rBackNormals,
 393         BOOL bCreateNormals = TRUE,
 394         BOOL bCreateTexture = TRUE);
 395     void AddBackNormals(
 396         const PolyPolygon3D& rPolyPoly3D,
 397         PolyPolygon3D& rNormalsBack,
 398         Vector3D& rOffset);
 399
 400     void CreateInBetween(
 401         const PolyPolygon3D& rPolyPolyFront,
 402         const PolyPolygon3D& rPolyPolyBack,
 403         const PolyPolygon3D& rFrontNormals,
 404         const PolyPolygon3D& rBackNormals,
 405         BOOL bCreateNormals = TRUE,
 406         double fSurroundFactor=1.0,
 407         double fTextureStart=0.0,
 408         double fTextureDepth=1.0,
 409         BOOL bRotateTexture90=FALSE);
 410     void AddInBetweenNormals(
 411         const PolyPolygon3D& rPolyPolyFront,
 412         const PolyPolygon3D& rPolyPolyBack,
 413         PolyPolygon3D& rNormals,
 414         BOOL bSmoothed = TRUE);
 415
 416     // Geometrieerzeugung
 417     void AddGeometry(
 418         const PolyPolygon3D& rPoly3D,
 419         BOOL bHintIsComplex=TRUE,
 420         BOOL bOutline=FALSE);
 421     void AddGeometry(
 422         const PolyPolygon3D& rPoly3D,
 423         const PolyPolygon3D& rVector3D,
 424         BOOL bHintIsComplex=TRUE,
 425         BOOL bOutline=FALSE);
 426     void AddGeometry(
 427         const PolyPolygon3D& rPoly3D,
 428         const PolyPolygon3D& rVector3D,
 429         const PolyPolygon3D& rNormal3D,
 430         BOOL bHintIsComplex=TRUE,
 431         BOOL bOutline=FALSE);
 432     void StartCreateGeometry();
 433
 434     // Segmenterzeugung
 435     void ImpCreateSegment(
 436         const PolyPolygon3D& rFront,            // vorderes Polygon
 437         const PolyPolygon3D& rBack,                     // hinteres Polygon
 438         const PolyPolygon3D* pPrev = 0L,        // smooth uebergang zu Vorgaenger
 439         const PolyPolygon3D* pNext = 0L,        // smooth uebergang zu Nachfolger
 440         BOOL bCreateFront = TRUE,                       // vorderen Deckel erzeugen
 441         BOOL bCreateBack = TRUE,                        // hinteren Deckel erzeugen
 442         double fPercentDiag = 0.05,                     // Anteil des Deckels an der Tiefe
 443         BOOL bSmoothLeft = TRUE,                        // Glaetten der umlaufenden Normalen links
 444         BOOL bSmoothRight = TRUE,                       // Glaetten der umlaufenden Normalen rechts
 445         BOOL bSmoothFrontBack = FALSE,          // Glaetten der Abschlussflaechen
 446         double fSurroundFactor = 1.0,           // Wertebereich der Texturkoordinaten im Umlauf
 447         double fTextureStart = 0.0,                     // TexCoor ueber Extrude-Tiefe
 448         double fTextureDepth = 1.0,                     // TexCoor ueber Extrude-Tiefe
 449         BOOL bCreateTexture = TRUE,
 450         BOOL bCreateNormals = TRUE,
 451         BOOL bCharacterExtrude = FALSE,         // FALSE=exakt, TRUE=ohne Ueberschneidungen
 452         BOOL bRotateTexture90 = FALSE,          // Textur der Seitenflaechen um 90 Grad kippen
 453         PolyPolygon3D* pLineGeometry = NULL // For creation of line geometry
 454         );
 455
 456     // #78972# Create vertical polygons for line polygon
 457     void ImpCompleteLinePolygon(PolyPolygon3D& rLinePolyPoly, sal_uInt16 nPolysPerRun, BOOL bClosed);
 458
 459     void SetDefaultAttributes(E3dDefaultAttributes& rDefault);
 460
 461     // convert given PolyPolygon3D to screen coor
 462
 463 public :
 464     TYPEINFO();
 465
 466     E3dCompoundObject();
 467     E3dCompoundObject(E3dDefaultAttributes& rDefault);
 468     virtual ~E3dCompoundObject();
 469
 470     // DoubleSided: TRUE/FALSE
 471     BOOL GetDoubleSided() const
 472         { return ((const Svx3DDoubleSidedItem&)GetUnmergedItemSet().Get(SDRATTR_3DOBJ_DOUBLE_SIDED)).GetValue(); }
 473
 474     // NormalsKind: 0 == FALSE/FALSE, 1 == TRUE/FALSE, else == TRUE/TRUE
 475     sal_uInt16 GetNormalsKind() const
 476         { return ((const Svx3DNormalsKindItem&)GetUnmergedItemSet().Get(SDRATTR_3DOBJ_NORMALS_KIND)).GetValue(); }
 477
 478     // NormalsInvert: TRUE/FALSE
 479     BOOL GetNormalsInvert() const
 480         { return ((const Svx3DNormalsInvertItem&)GetUnmergedItemSet().Get(SDRATTR_3DOBJ_NORMALS_INVERT)).GetValue(); }
 481
 482     // TextureProjX: 0 == FALSE/FALSE, 1 == TRUE/FALSE, else == TRUE/TRUE
 483     sal_uInt16 GetTextureProjectionX() const
 484         { return ((const Svx3DTextureProjectionXItem&)GetUnmergedItemSet().Get(SDRATTR_3DOBJ_TEXTURE_PROJ_X)).GetValue(); }
 485
 486     // TextureProjY: 0 == FALSE/FALSE, 1 == TRUE/FALSE, else == TRUE/TRUE
 487     sal_uInt16 GetTextureProjectionY() const
 488         { return ((const Svx3DTextureProjectionYItem&)GetUnmergedItemSet().Get(SDRATTR_3DOBJ_TEXTURE_PROJ_Y)).GetValue(); }
 489
 490     // Shadow3D: TRUE/FALSE
 491     BOOL GetShadow3D() const
 492         { return ((const Svx3DShadow3DItem&)GetUnmergedItemSet().Get(SDRATTR_3DOBJ_SHADOW_3D)).GetValue(); }
 493
 494     // MaterialColor: Color
 495     Color GetMaterialColor() const
 496         { return ((const Svx3DMaterialColorItem&)GetUnmergedItemSet().Get(SDRATTR_3DOBJ_MAT_COLOR)).GetValue(); }
 497
 498     // MaterialEmission: Color
 499     Color GetMaterialEmission() const
 500         { return ((const Svx3DMaterialEmissionItem&)GetUnmergedItemSet().Get(SDRATTR_3DOBJ_MAT_EMISSION)).GetValue(); }
 501
 502     // MaterialSpecular: Color
 503     Color GetMaterialSpecular() const
 504         { return ((const Svx3DMaterialSpecularItem&)GetUnmergedItemSet().Get(SDRATTR_3DOBJ_MAT_SPECULAR)).GetValue(); }
 505
 506     // MaterialSpecularIntensity:
 507     sal_uInt16 GetMaterialSpecularIntensity() const
 508         { return ((const Svx3DMaterialSpecularIntensityItem&)GetUnmergedItemSet().Get(SDRATTR_3DOBJ_MAT_SPECULAR_INTENSITY)).GetValue(); }
 509
 510     // TextureKind: 1 == Base3DTextureLuminance, 2 == Base3DTextureIntensity, 3 == Base3DTextureColor
 511     Base3DTextureKind GetTextureKind() const
 512         { return (Base3DTextureKind)((const Svx3DTextureKindItem&)GetUnmergedItemSet().Get(SDRATTR_3DOBJ_TEXTURE_KIND)).GetValue(); }
 513
 514     // TextureMode: 1 == Base3DTextureReplace, 2 == Base3DTextureModulate, 3 == Base3DTextureBlend
 515     Base3DTextureMode GetTextureMode() const
 516         { return (Base3DTextureMode)((const Svx3DTextureModeItem&)GetUnmergedItemSet().Get(SDRATTR_3DOBJ_TEXTURE_MODE)).GetValue(); }
 517
 518     // TextureFilter: TRUE/FALSE
 519     BOOL GetTextureFilter() const
 520         { return ((const Svx3DTextureFilterItem&)GetUnmergedItemSet().Get(SDRATTR_3DOBJ_TEXTURE_FILTER)).GetValue(); }
 521
 522     virtual UINT16 GetObjIdentifier() const;
 523     virtual void RecalcSnapRect();
 524     virtual void RecalcBoundRect();
 525     virtual const Volume3D& GetBoundVolume();
 526
 527     // private support routines for ItemSet access. NULL pointer means clear item.
 528     virtual void PostItemChange(const sal_uInt16 nWhich);
 529
 530     // Hittest, wird an Geometrie weitergegeben
 531     virtual SdrObject* CheckHit(const Point& rPnt, USHORT nTol,
 532         const SetOfByte* pVisiLayer) const;
 533
 534     virtual void WriteData(SvStream& rOut) const;
 535     virtual void ReadData(const SdrObjIOHeader& rHead, SvStream& rIn);
 536
 537     // 3D-Zeichenmethode
 538
 539     // Objekt als Kontur in das Polygon einfuegen
 540
 541     // Schatten fuer 3D-Objekte zeichnen
 542
 543     // #78972#
 544
 545     // Bitmaps fuer 3D-Darstellung von Gradients und Hatches holen
 546
 547     // Geometrieerzeugung
 548     void DestroyGeometry();
 549     virtual void CreateGeometry();
 550     void ReCreateGeometry(BOOL bCreateOldGeometry=FALSE);
 551
 552     // Give out simple line geometry
 553
 554     // Parameter Geometrieerzeugung setzen/lesen
 555     BOOL GetCreateNormals() const { return bCreateNormals; }
 556
 557     BOOL GetCreateTexture() const { return bCreateTexture; }
 558
 559     // Unterstuetzung Objekte lesen
 560     BOOL AreBytesLeft() const { return bBytesLeft; }
 561
 562     // Copy-Operator
 563
 564     // Ausgabeparameter an 3D-Kontext setzen
 565 private:
 566 public:
 567
 568     // DisplayGeometry rausruecken
 569     B3dGeometry& GetDisplayGeometry();
 570
 571     // Transformation auf die Geometrie anwenden
 572
 573     // Schattenattribute holen
 574     BOOL DoDrawShadow();
 575
 576     // WireFrame Darstellung eines Objektes
 577
 578     // Nromalen invertiert benutzen
 579 private:
 580     void SetInvertNormals(BOOL bNew);
 581 public:
 582
 583     // Material des Objektes
 584     const Color& GetMaterialAmbientColor() const { return aMaterialAmbientColor; }
 585     void SetMaterialAmbientColor(const Color& rColor);
 586
 587     const B3dMaterial& GetBackMaterial() const { return aBackMaterial; }
 588     BOOL GetUseDifferentBackMaterial() const { return bUseDifferentBackMaterial; }
 589 };
 590
 591 }//end of namespace binfilter
 592 #endif                  // _E3D_OBJ3D_HXX