Skip to content

C
core
Kaydet (Commit) bbe248d3 authored tarafından Ivo Hinkelmann's avatar Ivo Hinkelmann
Dosyalara gözat
Seçenekler

INTEGRATION: CWS aw024 (1.22.138); FILE MERGED 

2006/10/27 12:12:35 aw 1.22.138.13: #i70938# added hint where problems occurred
2006/09/21 18:49:48 aw 1.22.138.12: RESYNC: (1.26-1.27); FILE MERGED
2006/09/19 15:17:03 aw 1.22.138.11: #i69174# changed usage of Volume3D
2006/08/11 14:24:29 aw 1.22.138.10: #i39528# somehow init of some E3DScene members vanished, especially mp3DDepthRemapper
2006/07/07 16:03:12 aw 1.22.138.9: adaptions after resync SRC680m171->SRC680m174
2006/07/04 12:39:40 aw 1.22.138.8: RESYNC: (1.24-1.25); FILE MERGED
2005/09/18 03:44:04 aw 1.22.138.7: RESYNC: (1.23-1.24); FILE MERGED
2005/05/23 13:27:23 aw 1.22.138.6: i39529#
2005/05/19 12:31:14 aw 1.22.138.5: #i39529#
2005/05/12 16:39:23 aw 1.22.138.4: #i39529#
2005/04/26 15:04:14 aw 1.22.138.3: #i39528#
2005/03/24 00:24:41 aw 1.22.138.2: RESYNC: (1.22-1.23); FILE MERGED
2004/12/23 16:52:34 aw 1.22.138.1: #i39525
üst f42adf82
Hide whitespace changes
Inline Side-by-side
Showing with 244 additions and 568 deletions
svx/source/engine3d/scene3d.cxx
Dosyayı görüntüle @ bbe248d3
...@@ -4,9 +4,9 @@ ...@@ -4,9 +4,9 @@
* *
* $RCSfile: scene3d.cxx,v $ * $RCSfile: scene3d.cxx,v $
* *
* $Revision: 1.27 $ * $Revision: 1.28 $
* *
* last change: $Author: obo $ $Date: 2006-09-17 04:58:39 $ * last change: $Author: ihi $ $Date: 2006-11-14 13:21:55 $
* *
* The Contents of this file are made available subject to * The Contents of this file are made available subject to
* the terms of GNU Lesser General Public License Version 2.1. * the terms of GNU Lesser General Public License Version 2.1.
...@@ -118,6 +118,10 @@ ...@@ -118,6 +118,10 @@
#include <svx/sdr/contact/viewcontactofe3dscene.hxx> #include <svx/sdr/contact/viewcontactofe3dscene.hxx>
#endif #endif
#ifndef _SVDDRAG_HXX //autogen
#include "svddrag.hxx"
#endif
// for ::std::sort // for ::std::sort
#include <algorithm> #include <algorithm>
...@@ -274,7 +278,7 @@ TYPEINIT1(E3dScene, E3dObject); ...@@ -274,7 +278,7 @@ TYPEINIT1(E3dScene, E3dObject);
E3dScene::E3dScene() E3dScene::E3dScene()
: E3dObject(), : E3dObject(),
aCamera(Vector3D(0,0,4), Vector3D()), aCamera(basegfx::B3DPoint(0.0, 0.0, 4.0), basegfx::B3DPoint()),
aPaintTime(), aPaintTime(),
nDisplayQuality(255), nDisplayQuality(255),
mp3DDepthRemapper(0L), mp3DDepthRemapper(0L),
...@@ -290,7 +294,7 @@ E3dScene::E3dScene() ...@@ -290,7 +294,7 @@ E3dScene::E3dScene()
E3dScene::E3dScene(E3dDefaultAttributes& rDefault) E3dScene::E3dScene(E3dDefaultAttributes& rDefault)
: E3dObject(), : E3dObject(),
aCamera(Vector3D(0,0,4), Vector3D()), aCamera(basegfx::B3DPoint(0.0, 0.0, 4.0), basegfx::B3DPoint()),
aPaintTime(), aPaintTime(),
nDisplayQuality(255), nDisplayQuality(255),
mp3DDepthRemapper(0L), mp3DDepthRemapper(0L),
...@@ -357,16 +361,15 @@ void E3dScene::SetDefaultAttributes(E3dDefaultAttributes& rDefault) ...@@ -357,16 +361,15 @@ void E3dScene::SetDefaultAttributes(E3dDefaultAttributes& rDefault)
aCamera.SetDeviceWindow(Rectangle(0, 0, 10, 10)); aCamera.SetDeviceWindow(Rectangle(0, 0, 10, 10));
Rectangle aRect(0, 0, 10, 10); Rectangle aRect(0, 0, 10, 10);
aCameraSet.SetViewportRectangle(aRect); aCameraSet.SetViewportRectangle(aRect);
//BFS01nSortingMode = E3D_SORT_FAST_SORTING | E3D_SORT_IN_PARENTS | E3D_SORT_TEST_LENGTH;
// set defaults for Camera from ItemPool // set defaults for Camera from ItemPool
aCamera.SetProjection(GetPerspective()); aCamera.SetProjection(GetPerspective());
Vector3D aActualPosition = aCamera.GetPosition(); basegfx::B3DPoint aActualPosition(aCamera.GetPosition());
double fNew = GetDistance(); double fNew = GetDistance();
if(fabs(fNew - aActualPosition.Z()) > 1.0) if(fabs(fNew - aActualPosition.getZ()) > 1.0)
{ {
aCamera.SetPosition( Vector3D( aActualPosition.X(), aActualPosition.Y(), fNew) ); aCamera.SetPosition( basegfx::B3DPoint( aActualPosition.getX(), aActualPosition.getY(), fNew) );
} }
fNew = GetFocalLength() / 100.0; fNew = GetFocalLength() / 100.0;
...@@ -479,7 +482,7 @@ UINT16 E3dScene::GetObjIdentifier() const ...@@ -479,7 +482,7 @@ UINT16 E3dScene::GetObjIdentifier() const
|* |*
\************************************************************************/ \************************************************************************/
USHORT E3dScene::GetHdlCount() const sal_uInt32 E3dScene::GetHdlCount() const
{ {
// Ueberladung aus E3dObject rueckgaengig machen // Ueberladung aus E3dObject rueckgaengig machen
return SdrAttrObj::GetHdlCount(); return SdrAttrObj::GetHdlCount();
...@@ -573,13 +576,12 @@ void E3dScene::SetCamera(const Camera3D& rNewCamera) ...@@ -573,13 +576,12 @@ void E3dScene::SetCamera(const Camera3D& rNewCamera)
GetCameraSet().SetRatio(0.0); GetCameraSet().SetRatio(0.0);
// Abbildungsgeometrie setzen // Abbildungsgeometrie setzen
Vector3D aVRP = rCam.GetViewPoint(); basegfx::B3DPoint aVRP(rCam.GetViewPoint());
Vector3D aVPN = aVRP - rCam.GetVRP(); basegfx::B3DVector aVPN(aVRP - rCam.GetVRP());
Vector3D aVUV = rCam.GetVUV(); basegfx::B3DVector aVUV(rCam.GetVUV());
// #91047# use SetViewportValues() to set VRP, VPN and VUV as vectors, too. // #91047# use SetViewportValues() to set VRP, VPN and VUV as vectors, too.
// Else these values would not be exported/imported correctly. // Else these values would not be exported/imported correctly.
//GetCameraSet().SetOrientation(aVRP, aVPN, aVUV);
GetCameraSet().SetViewportValues(aVRP, aVPN, aVUV); GetCameraSet().SetViewportValues(aVRP, aVPN, aVUV);
// Perspektive setzen // Perspektive setzen
...@@ -702,120 +704,142 @@ void E3dScene::SetFitInSnapRect(FASTBOOL bFit) ...@@ -702,120 +704,142 @@ void E3dScene::SetFitInSnapRect(FASTBOOL bFit)
|* |*
\************************************************************************/ \************************************************************************/
Volume3D E3dScene::FitInSnapRect() basegfx::B3DRange E3dScene::FitInSnapRect()
{ {
// Alter Kram basegfx::B3DRange aNewVol;
Matrix4D aFullTrans = GetFullTransform(); const sal_uInt32 nObjCount(GetSubList() ? GetSubList()->GetObjCount() : 0L);
aCamera.FitViewToVolume(GetBoundVolume(), aFullTrans);
// Neuer Kram if(nObjCount)
// Maximas holen in Augkoordinaten zwecks Z-Werten
Volume3D aNewVol;
Vector3D aTfVec;
Vol3DPointIterator aIter(GetBoundVolume());
GetCameraSet().SetObjectTrans(aFullTrans);
while ( aIter.Next(aTfVec) )
{ {
aTfVec = GetCameraSet().ObjectToEyeCoor(aTfVec); // Alter Kram
aNewVol.Union(aTfVec); basegfx::B3DHomMatrix aFullTrans(GetFullTransform());
} aCamera.FitViewToVolume(GetBoundVolume(), aFullTrans);
// ... und merken // Neuer Kram
double fZMin = -aNewVol.MaxVec().Z(); // Maximas holen in Augkoordinaten zwecks Z-Werten
double fZMax = -aNewVol.MinVec().Z(); basegfx::B3DPoint aTfVec;
Vol3DPointIterator aIter(GetBoundVolume());
// Jetzt XY-Werte projizieren auf Projektionsflaeche GetCameraSet().SetObjectTrans(aFullTrans);
// in Device-Koordinaten
Matrix4D aWorldToDevice = GetCameraSet().GetOrientation(); while ( aIter.Next(aTfVec) )
if(aCamera.GetProjection() == PR_PERSPECTIVE) {
aWorldToDevice.Frustum(-1.0, 1.0, -1.0, 1.0, fZMin, fZMax); aTfVec = GetCameraSet().ObjectToEyeCoor(aTfVec);
else aNewVol.expand(aTfVec);
aWorldToDevice.Ortho(-1.0, 1.0, -1.0, 1.0, fZMin, fZMax); }
aNewVol.Reset();
aIter.Reset(); // ... und merken
while ( aIter.Next(aTfVec) ) double fZMin(-aNewVol.getMaxZ());
{ double fZMax(-aNewVol.getMinZ());
aTfVec = GetCameraSet().ObjectToWorldCoor(aTfVec);
aTfVec *= aWorldToDevice; // Jetzt XY-Werte projizieren auf Projektionsflaeche
aNewVol.Union(aTfVec); // in Device-Koordinaten
} basegfx::B3DHomMatrix aWorldToDevice(GetCameraSet().GetOrientation());
// Labels behandeln
ULONG nLabelCnt = aLabelList.Count();
if ( nLabelCnt > 0 )
{
// Vorlaeufige Projektion bestimmen und Transformation in
// ViewKoordinaten bestimmen
Matrix4D aMatWorldToView = GetCameraSet().GetOrientation();
if(aCamera.GetProjection() == PR_PERSPECTIVE) if(aCamera.GetProjection() == PR_PERSPECTIVE)
aMatWorldToView.Frustum(aNewVol.MinVec().X(), aNewVol.MaxVec().X(), {
aNewVol.MinVec().Y(), aNewVol.MaxVec().Y(), fZMin, fZMax); aWorldToDevice.frustum(-1.0, 1.0, -1.0, 1.0, fZMin, fZMax);
}
else else
aMatWorldToView.Ortho(aNewVol.MinVec().X(), aNewVol.MaxVec().X(), {
aNewVol.MinVec().Y(), aNewVol.MaxVec().Y(), fZMin, fZMax); aWorldToDevice.ortho(-1.0, 1.0, -1.0, 1.0, fZMin, fZMax);
}
aNewVol.reset();
aIter.Reset();
while ( aIter.Next(aTfVec) )
{
aTfVec = GetCameraSet().ObjectToWorldCoor(aTfVec);
aTfVec *= aWorldToDevice;
aNewVol.expand(aTfVec);
}
// Labels behandeln
const sal_uInt32 nLabelCnt(aLabelList.Count());
if ( nLabelCnt )
{
// Vorlaeufige Projektion bestimmen und Transformation in
// ViewKoordinaten bestimmen
basegfx::B3DHomMatrix aMatWorldToView(GetCameraSet().GetOrientation());
// Logische Abmessungen der Szene holen if(aCamera.GetProjection() == PR_PERSPECTIVE)
Rectangle aSceneRect = GetSnapRect(); {
aMatWorldToView.frustum(aNewVol.getMinX(), aNewVol.getMaxX(), aNewVol.getMinY(), aNewVol.getMaxY(), fZMin, fZMax);
}
else
{
aMatWorldToView.ortho(aNewVol.getMinX(), aNewVol.getMaxX(), aNewVol.getMinY(), aNewVol.getMaxY(), fZMin, fZMax);
}
// Matrix DeviceToView aufbauen // Logische Abmessungen der Szene holen
Vector3D aTranslate, aScale; Rectangle aSceneRect = GetSnapRect();
aTranslate[0] = (double)aSceneRect.Left() + (aSceneRect.GetWidth() / 2.0); // Matrix DeviceToView aufbauen
aTranslate[1] = (double)aSceneRect.Top() + (aSceneRect.GetHeight() / 2.0); basegfx::B3DPoint aTranslate, aScale;
aTranslate[2] = ZBUFFER_DEPTH_RANGE / 2.0;
// Skalierung aTranslate.setX((double)aSceneRect.Left() + (aSceneRect.GetWidth() / 2.0));
aScale[0] = (aSceneRect.GetWidth() - 1) / 2.0; aTranslate.setY((double)aSceneRect.Top() + (aSceneRect.GetHeight() / 2.0));
aScale[1] = (aSceneRect.GetHeight() - 1) / -2.0; aTranslate.setZ(ZBUFFER_DEPTH_RANGE / 2.0);
aScale[2] = ZBUFFER_DEPTH_RANGE / 2.0;
aMatWorldToView.Scale(aScale); // Skalierung
aMatWorldToView.Translate(aTranslate); aScale.setX((aSceneRect.GetWidth() - 1) / 2.0);
aScale.setY((aSceneRect.GetHeight() - 1) / -2.0);
aScale.setZ(ZBUFFER_DEPTH_RANGE / 2.0);
// Inverse Matrix ViewToDevice aufbauen aMatWorldToView.scale(aScale.getX(), aScale.getY(), aScale.getZ());
Matrix4D aMatViewToWorld(aMatWorldToView); aMatWorldToView.translate(aTranslate.getX(), aTranslate.getY(), aTranslate.getZ());
aMatViewToWorld.Invert();
for (ULONG i = 0; i < nLabelCnt; i++) // Inverse Matrix ViewToDevice aufbauen
{ basegfx::B3DHomMatrix aMatViewToWorld(aMatWorldToView);
E3dLabelObj* p3DObj = aLabelList.GetObject(i); aMatViewToWorld.invert();
const SdrObject* pObj = p3DObj->Get2DLabelObj();
for (sal_uInt32 i = 0; i < nLabelCnt; i++)
// View- Abmessungen des Labels holen {
const Rectangle& rObjRect = pObj->GetLogicRect(); E3dLabelObj* p3DObj = aLabelList.GetObject(i);
const SdrObject* pObj = p3DObj->Get2DLabelObj();
// Position des Objektes in Weltkoordinaten ermitteln
Matrix4D aObjTrans = p3DObj->GetFullTransform(); // View- Abmessungen des Labels holen
Vector3D aObjPos = aObjTrans * p3DObj->GetPosition(); const Rectangle& rObjRect = pObj->GetLogicRect();
// View-Position des Objektes feststellen // Position des Objektes in Weltkoordinaten ermitteln
// nach ViewKoordinaten basegfx::B3DHomMatrix aObjTrans(p3DObj->GetFullTransform());
aObjPos *= aMatWorldToView; // Here, without the 'B3DPoint operator*( const B3DHomMatrix& rMat, const B3DPoint& rPoint )'
// from b3dpoint.hxx, the wrong multiplication is taken (the one with B3DVector). This
// Relative Position des Labels in View-Koordinaten // leads to wrong results since tre translation is not added to vector-matrix multiplications.
Vector3D aRelPosOne(pObj->GetRelativePos(), aObjPos.Z()); basegfx::B3DPoint aObjPos(aObjTrans * p3DObj->GetPosition());
aRelPosOne.X() += aObjPos.X();
aRelPosOne.Y() += aObjPos.Y(); // View-Position des Objektes feststellen
Vector3D aRelPosTwo(aRelPosOne); // nach ViewKoordinaten
aRelPosTwo.X() += rObjRect.GetWidth(); aObjPos *= aMatWorldToView;
aRelPosTwo.Y() += rObjRect.GetHeight();
// Relative Position des Labels in View-Koordinaten
// Jetzt Eckpunkte in DeviceKoordinaten bestimmen und basegfx::B3DPoint aRelPosOne(
// den Abmessungen hinzufuegen pObj->GetRelativePos().X() + aObjPos.getX(),
aRelPosOne *= aMatViewToWorld; pObj->GetRelativePos().Y() + aObjPos.getY(),
aRelPosOne *= aWorldToDevice; aObjPos.getZ());
aNewVol.Union(aRelPosOne);
basegfx::B3DPoint aRelPosTwo(
aRelPosTwo *= aMatViewToWorld; aRelPosOne.getX() + (double)rObjRect.GetWidth(),
aRelPosTwo *= aWorldToDevice; aRelPosOne.getY() + (double)rObjRect.GetHeight(),
aNewVol.Union(aRelPosTwo); aRelPosOne.getZ());
// Jetzt Eckpunkte in DeviceKoordinaten bestimmen und
// den Abmessungen hinzufuegen
aRelPosOne *= aMatViewToWorld;
aRelPosOne *= aWorldToDevice;
aNewVol.expand(aRelPosOne);
aRelPosTwo *= aMatViewToWorld;
aRelPosTwo *= aWorldToDevice;
aNewVol.expand(aRelPosTwo);
}
} }
}
// Z-Werte eintragen // Z-Werte eintragen
aNewVol.MinVec().Z() = fZMin; aNewVol = basegfx::B3DRange(aNewVol.getMinX(), aNewVol.getMinY(), fZMin, aNewVol.getMaxX(), aNewVol.getMaxY(), fZMax);
aNewVol.MaxVec().Z() = fZMax; }
// #110988# // #110988#
ImpCleanup3DDepthMapper(); ImpCleanup3DDepthMapper();
...@@ -852,11 +876,11 @@ void E3dScene::InitTransformationSet() ...@@ -852,11 +876,11 @@ void E3dScene::InitTransformationSet()
B3dCamera& rSet = GetCameraSet(); B3dCamera& rSet = GetCameraSet();
// Transformation auf Weltkoordinaten holen // Transformation auf Weltkoordinaten holen
Matrix4D mTransform = GetFullTransform(); basegfx::B3DHomMatrix mTransform = GetFullTransform();
rSet.SetObjectTrans(mTransform); rSet.SetObjectTrans(mTransform);
// 3D Ausgabe vorbereiten, Maximas holen in DeviceKoordinaten // 3D Ausgabe vorbereiten, Maximas holen in DeviceKoordinaten
Volume3D aVolume = FitInSnapRect(); basegfx::B3DRange aVolume(FitInSnapRect());
// Maximas fuer Abbildung verwenden // Maximas fuer Abbildung verwenden
rSet.SetDeviceVolume(aVolume, FALSE); rSet.SetDeviceVolume(aVolume, FALSE);
...@@ -866,223 +890,6 @@ void E3dScene::InitTransformationSet() ...@@ -866,223 +890,6 @@ void E3dScene::InitTransformationSet()
ImpCleanup3DDepthMapper(); ImpCleanup3DDepthMapper();
} }
/*************************************************************************
|*
|* sichern mit neuer Methode und zukunftskompatibilitaet
|* Die Zahl 3560 ist die Major-Update-Nummer * 10 zu der die Umstellung
|* erfolgte. Dies ist leider das korrekte Verhalten, die 3d-Engine hat keine
|* eigene Versionsnummer sondern ist an die der Drawing-Engine gekoppelt.
|* Probleme gibt es immer dann wenn einen neue Version ein altes Format
|* schreiben soll: Hier wird von der Drawing-Engine trotzdem die neue Nummer
|* verwendet.
|*
\************************************************************************/
//BFS01void E3dScene::WriteData(SvStream& rOut) const
//BFS01{
//BFS01#ifndef SVX_LIGHT
//BFS01 long nVersion = rOut.GetVersion(); // Build_Nr * 10 z.B. 3810
//BFS01 if(nVersion < 3830)
//BFS01 {
//BFS01 // Hier die Lichtobjekte erzeugen, um im alten Format schreiben zu koennen
//BFS01 ((E3dScene*)(this))->CreateLightObjectsFromLightGroup();
//BFS01 }
//BFS01
//BFS01 // Schreiben
//BFS01 E3dObject::WriteData(rOut);
//BFS01
//BFS01 if(nVersion < 3830)
//BFS01 {
//BFS01 // Lichtobjekte wieder wegnehmen
//BFS01 ((E3dScene*)(this))->RemoveLightObjects();
//BFS01 }
//BFS01 else
//BFS01 {
//BFS01#ifdef E3D_STREAMING
//BFS01 SdrDownCompat aCompat(rOut, STREAM_WRITE);
//BFS01#ifdef DBG_UTIL
//BFS01 aCompat.SetID("B3dLightGroup");
//BFS01#endif
//BFS01 // LightGroup schreiben
//BFS01 aLightGroup.WriteData(rOut);
//BFS01
//BFS01#endif
//BFS01 }
//BFS01
//BFS01#ifdef E3D_STREAMING
//BFS01 SdrDownCompat aCompat(rOut, STREAM_WRITE);
//BFS01#ifdef DBG_UTIL
//BFS01 aCompat.SetID("E3dScene");
//BFS01#endif
//BFS01
//BFS01 DBG_ASSERT (rOut.GetVersion(),"3d-Engine: Keine Version am Stream gesetzt!");
//BFS01 if (rOut.GetVersion() < 3560) // FG: Das ist der Zeitpunkt der Umstellung
//BFS01 {
//BFS01 rOut << aCamera;
//BFS01 }
//BFS01 if (rOut.GetVersion() >= 3560)
//BFS01 {
//BFS01 aCamera.WriteData(rOut);
//BFS01 }
//BFS01
//BFS01 rOut << BOOL(bDoubleBuffered);
//BFS01 rOut << BOOL(bClipping);
//BFS01 rOut << BOOL(bFitInSnapRect);
//BFS01 rOut << nSortingMode;
//BFS01
//BFS01 // neu ab 377:
//BFS01 Vector3D aPlaneDirection = GetShadowPlaneDirection();
//BFS01 rOut << aPlaneDirection;
//BFS01
//BFS01 // neu ab 383:
//BFS01 rOut << (BOOL)bDither;
//BFS01
//BFS01 // neu ab 384:
//BFS01 sal_uInt16 nShadeMode = GetShadeMode();
//BFS01 if(nShadeMode == 0)
//BFS01 rOut << (sal_uInt16)Base3DFlat;
//BFS01 else if(nShadeMode == 1)
//BFS01 rOut << (sal_uInt16)Base3DPhong;
//BFS01 else
//BFS01 rOut << (sal_uInt16)Base3DSmooth;
//BFS01 rOut << (BOOL)(nShadeMode > 2);
//BFS01
//BFS01#endif
//BFS01#endif // #ifndef SVX_LIGHT
//BFS01}
/*************************************************************************
|*
|* laden
|*
\************************************************************************/
//BFS01void E3dScene::ReadData(const SdrObjIOHeader& rHead, SvStream& rIn)
//BFS01{
//BFS01 if (ImpCheckSubRecords (rHead, rIn))
//BFS01 {
//BFS01 E3dObject::ReadData(rHead, rIn);
//BFS01
//BFS01 if(CountNumberOfLights())
//BFS01 {
//BFS01 // An dieser Stelle die gelesenen Lampen ausmerzen
//BFS01 // und in die neue Struktur ueberfuehren
//BFS01 FillLightGroup();
//BFS01 RemoveLightObjects();
//BFS01 }
//BFS01 long nVersion = rIn.GetVersion(); // Build_Nr * 10 z.B. 3810
//BFS01 if(nVersion >= 3830)
//BFS01 {
//BFS01 SdrDownCompat aCompat(rIn, STREAM_READ);
//BFS01#ifdef DBG_UTIL
//BFS01 aCompat.SetID("B3dLightGroup");
//BFS01#endif
//BFS01 if(aCompat.GetBytesLeft())
//BFS01 {
//BFS01 // LightGroup lesen
//BFS01 aLightGroup.ReadData(rIn);
//BFS01 }
//BFS01 }
//BFS01
//BFS01 SdrDownCompat aCompat(rIn, STREAM_READ);
//BFS01#ifdef DBG_UTIL
//BFS01 aCompat.SetID("E3dScene");
//BFS01#endif
//BFS01 BOOL bTmp;
//BFS01
//BFS01 DBG_ASSERT (rIn.GetVersion(),"3d-Engine: Keine Version am Stream gesetzt!");
//BFS01
//BFS01 if ((rIn.GetVersion() < 3560) || (rHead.GetVersion() <= 12))
//BFS01 {
//BFS01 rIn >> aCamera;
//BFS01 }
//BFS01 if ((rIn.GetVersion() >= 3560) && (rHead.GetVersion() >= 13))
//BFS01 {
//BFS01 aCamera.ReadData(rHead, rIn);
//BFS01 }
//BFS01
//BFS01 // Neue Kamera aus alter fuellen
//BFS01 Camera3D& rCam = (Camera3D&)GetCamera();
//BFS01
//BFS01 // Ratio abschalten
//BFS01 if(rCam.GetAspectMapping() == AS_NO_MAPPING)
//BFS01 GetCameraSet().SetRatio(0.0);
//BFS01
//BFS01 // Abbildungsgeometrie setzen
//BFS01 Vector3D aVRP = rCam.GetViewPoint();
//BFS01 Vector3D aVPN = aVRP - rCam.GetVRP();
//BFS01 Vector3D aVUV = rCam.GetVUV();
//BFS01 GetCameraSet().SetOrientation(aVRP, aVPN, aVUV);
//BFS01
//BFS01 // Perspektive setzen
//BFS01 GetCameraSet().SetPerspective(rCam.GetProjection() == PR_PERSPECTIVE);
//BFS01 GetCameraSet().SetViewportRectangle((Rectangle&)rCam.GetDeviceWindow());
//BFS01
//BFS01 rIn >> bTmp; bDoubleBuffered = bTmp;
//BFS01 rIn >> bTmp; bClipping = bTmp;
//BFS01 rIn >> bTmp; bFitInSnapRect = bTmp;
//BFS01
//BFS01 if (aCompat.GetBytesLeft() >= sizeof(UINT32))
//BFS01 {
//BFS01 rIn >> nSortingMode;
//BFS01 }
//BFS01
//BFS01 // neu ab 377:
//BFS01 if (aCompat.GetBytesLeft() >= sizeof(Vector3D))
//BFS01 {
//BFS01 Vector3D aShadowVec;
//BFS01 rIn >> aShadowVec;
//BFS01 SetShadowPlaneDirection(aShadowVec);
//BFS01 }
//BFS01
//BFS01 // neu ab 383:
//BFS01 if (aCompat.GetBytesLeft() >= sizeof(BOOL))
//BFS01 {
//BFS01 rIn >> bTmp; bDither = bTmp;
//BFS01 }
//BFS01
//BFS01 // neu ab 384:
//BFS01 if (aCompat.GetBytesLeft() >= sizeof(UINT16))
//BFS01 {
//BFS01 UINT16 nTmp;
//BFS01 rIn >> nTmp;
//BFS01 if(nTmp == (Base3DShadeModel)Base3DFlat)
//BFS01 {
//BFS01 GetProperties().SetObjectItemDirect(Svx3DShadeModeItem(0));
//BFS01 }
//BFS01 else if(nTmp == (Base3DShadeModel)Base3DPhong)
//BFS01 {
//BFS01 GetProperties().SetObjectItemDirect(Svx3DShadeModeItem(1));
//BFS01 }
//BFS01 else
//BFS01 {
//BFS01 GetProperties().SetObjectItemDirect(Svx3DShadeModeItem(2));
//BFS01 }
//BFS01 }
//BFS01 if (aCompat.GetBytesLeft() >= sizeof(BOOL))
//BFS01 {
//BFS01 rIn >> bTmp;
//BFS01 if(bTmp)
//BFS01 {
//BFS01 GetProperties().SetObjectItemDirect(Svx3DShadeModeItem(3));
//BFS01 }
//BFS01 }
//BFS01
//BFS01 // SnapRects der Objekte ungueltig
//BFS01 SetRectsDirty();
//BFS01
//BFS01 // Transformationen initialisieren, damit bei RecalcSnapRect()
//BFS01 // richtig gerechnet wird
//BFS01 InitTransformationSet();
//BFS01
//BFS01 RebuildLists();
//BFS01
//BFS01 // set items from combined read objects like lightgroup and camera
//BFS01 ((sdr::properties::E3dSceneProperties&)GetProperties()).SetLightItemsFromLightGroup(aLightGroup);
//BFS01 ((sdr::properties::E3dSceneProperties&)GetProperties()).SetSceneItemsFromCamera();
//BFS01 }
//BFS01}
/************************************************************************* /*************************************************************************
|* |*
|* Einpassen der Objekte in umschliessendes Rechteck aus-/einschalten |* Einpassen der Objekte in umschliessendes Rechteck aus-/einschalten
...@@ -1091,24 +898,23 @@ void E3dScene::InitTransformationSet() ...@@ -1091,24 +898,23 @@ void E3dScene::InitTransformationSet()
void E3dScene::FitSnapRectToBoundVol() void E3dScene::FitSnapRectToBoundVol()
{ {
Vector3D aTfVec; basegfx::B3DPoint aTfVec;
Volume3D aFitVol; Volume3D aFitVol;
SetBoundVolInvalid(); SetBoundVolInvalid();
Matrix4D aTransform = aCamera.GetViewTransform() * GetFullTransform(); // #112587# basegfx::B3DHomMatrix aTransform = aCamera.GetViewTransform() * GetFullTransform(); // #112587#
Vol3DPointIterator aIter(GetBoundVolume(), &aTransform); Vol3DPointIterator aIter(GetBoundVolume(), &aTransform);
Rectangle aRect; Rectangle aRect;
while ( aIter.Next(aTfVec) ) while ( aIter.Next(aTfVec) )
{ {
aCamera.DoProjection(aTfVec); aTfVec = aCamera.DoProjection(aTfVec);
aFitVol.Union(aTfVec); aFitVol.expand(aTfVec);
Vector3D aZwi = aCamera.MapToDevice(aTfVec); basegfx::B3DPoint aZwi(aCamera.MapToDevice(aTfVec));
Point aP((long)aZwi.X(), (long)aZwi.Y()); Point aP((long)aZwi.getX(), (long)aZwi.getY());
aRect.Union(Rectangle(aP, aP)); aRect.Union(Rectangle(aP, aP));
} }
aCamera.SetViewWindow(aFitVol.MinVec().X(), aFitVol.MinVec().Y(), aCamera.SetViewWindow(aFitVol.getMinX(), aFitVol.getMinY(), aFitVol.getWidth(), aFitVol.getHeight());
aFitVol.GetWidth(), aFitVol.GetHeight());
SetSnapRect(aRect); SetSnapRect(aRect);
// Die SnapRects aller beteiligten Objekte muessen auf dieser // Die SnapRects aller beteiligten Objekte muessen auf dieser
...@@ -1130,23 +936,28 @@ void E3dScene::FitSnapRectToBoundVol() ...@@ -1130,23 +936,28 @@ void E3dScene::FitSnapRectToBoundVol()
void E3dScene::CorrectSceneDimensions() void E3dScene::CorrectSceneDimensions()
{ {
// SnapRects der Objekte ungueltig const sal_uInt32 nObjCount(GetSubList() ? GetSubList()->GetObjCount() : 0L);
SetRectsDirty();
// SnapRect anpassen, invalidiert auch die SnapRects if(nObjCount)
// der enthaltenen Objekte {
FitSnapRectToBoundVol(); // SnapRects der Objekte ungueltig
SetRectsDirty();
// Neues BoundVolume der Kamera holen // SnapRect anpassen, invalidiert auch die SnapRects
Volume3D aVolume = FitInSnapRect(); // der enthaltenen Objekte
FitSnapRectToBoundVol();
// Neues BoundVolume an der Kamera setzen // Neues BoundVolume der Kamera holen
GetCameraSet().SetDeviceVolume(aVolume, FALSE); basegfx::B3DRange aVolume(FitInSnapRect());
// Danach noch die SnapRects der enthaltenen Objekte // Neues BoundVolume an der Kamera setzen
// invalidieren, um diese auf der neuen Grundlage berechnen GetCameraSet().SetDeviceVolume(aVolume, FALSE);
// zu lassen (falls diese von FitInSnapRect() berechnet wurden)
SetRectsDirty(); // Danach noch die SnapRects der enthaltenen Objekte
// invalidieren, um diese auf der neuen Grundlage berechnen
// zu lassen (falls diese von FitInSnapRect() berechnet wurden)
SetRectsDirty();
}
// #110988# // #110988#
ImpCleanup3DDepthMapper(); ImpCleanup3DDepthMapper();
...@@ -1167,7 +978,6 @@ void E3dScene::operator=(const SdrObject& rObj) ...@@ -1167,7 +978,6 @@ void E3dScene::operator=(const SdrObject& rObj)
bDoubleBuffered = r3DObj.bDoubleBuffered; bDoubleBuffered = r3DObj.bDoubleBuffered;
bClipping = r3DObj.bClipping; bClipping = r3DObj.bClipping;
bFitInSnapRect = r3DObj.bFitInSnapRect; bFitInSnapRect = r3DObj.bFitInSnapRect;
//BFS01nSortingMode = r3DObj.nSortingMode;
// neu ab 377: // neu ab 377:
aCameraSet = r3DObj.aCameraSet; aCameraSet = r3DObj.aCameraSet;
...@@ -1381,189 +1191,6 @@ void E3dScene::NbcRotate(const Point& rRef, long nWink, double sn, double cs) ...@@ -1381,189 +1191,6 @@ void E3dScene::NbcRotate(const Point& rRef, long nWink, double sn, double cs)
SetRectsDirty(); SetRectsDirty();
} }
/*************************************************************************
|*
|* Licht-Objekte rauswerfen
|*
\************************************************************************/
//BFS01void E3dScene::RemoveLightObjects()
//BFS01{
//BFS01 SdrObjList* pSubList = GetSubList();
//BFS01 if(pSubList)
//BFS01 {
//BFS01 SdrObjListIter a3DIterator(*pSubList, IM_DEEPWITHGROUPS);
//BFS01 while ( a3DIterator.IsMore() )
//BFS01 {
//BFS01 E3dObject* pObj = (E3dObject*) a3DIterator.Next();
//BFS01 DBG_ASSERT(pObj->ISA(E3dObject), "AW: In Szenen sind nur 3D-Objekte erlaubt!");
//BFS01 if(pObj->ISA(E3dLight))
//BFS01 {
//BFS01 // Weg damit
//BFS01 Remove3DObj(pObj);
//BFS01 }
//BFS01 }
//BFS01 }
//BFS01}
/*************************************************************************
|*
|* Licht-Objekte erzeugen, um kompatibel zur 4.0
|* speichern zu koennen
|*
\************************************************************************/
//BFS01void E3dScene::CreateLightObjectsFromLightGroup()
//BFS01{
//BFS01 if(aLightGroup.IsLightingEnabled())
//BFS01 {
//BFS01 // Global Ambient Light
//BFS01 const Color& rAmbient = aLightGroup.GetGlobalAmbientLight();
//BFS01 if(rAmbient != Color(COL_BLACK))
//BFS01 Insert3DObj(new E3dLight(Vector3D(), rAmbient, 1.0));
//BFS01
//BFS01 // Andere Lichter
//BFS01 for(UINT16 a=0;a<BASE3D_MAX_NUMBER_LIGHTS;a++)
//BFS01 {
//BFS01 B3dLight& rLight = aLightGroup.GetLightObject((Base3DLightNumber)(Base3DLight0 + a));
//BFS01 if(rLight.IsEnabled())
//BFS01 {
//BFS01 if(rLight.IsDirectionalSource())
//BFS01 {
//BFS01 // erzeuge E3dDistantLight
//BFS01 Insert3DObj(new E3dDistantLight(Vector3D(),
//BFS01 rLight.GetPosition(),
//BFS01 rLight.GetIntensity(Base3DMaterialDiffuse), 1.0));
//BFS01 }
//BFS01 else
//BFS01 {
//BFS01 // erzeuge E3dPointLight
//BFS01 Insert3DObj(new E3dPointLight(rLight.GetPosition(),
//BFS01 rLight.GetIntensity(Base3DMaterialDiffuse), 1.0));
//BFS01 }
//BFS01 }
//BFS01 }
//BFS01 }
//BFS01}
/*************************************************************************
|*
|* Beleuchtung aus dem alten Beleuchtungsmodell uebernehmen
|*
\************************************************************************/
//BFS01void E3dScene::FillLightGroup()
//BFS01{
//BFS01 SdrObjList* pSubList = GetSubList();
//BFS01 BOOL bLampFound = FALSE;
//BFS01
//BFS01 if(pSubList)
//BFS01 {
//BFS01 SdrObjListIter a3DIterator(*pSubList, IM_DEEPWITHGROUPS);
//BFS01 Base3DLightNumber eLight = Base3DLight0;
//BFS01
//BFS01 // AmbientLight aus
//BFS01 aLightGroup.SetGlobalAmbientLight(Color(COL_BLACK));
//BFS01
//BFS01 while ( a3DIterator.IsMore() )
//BFS01 {
//BFS01 E3dObject* pObj = (E3dObject*) a3DIterator.Next();
//BFS01 DBG_ASSERT(pObj->ISA(E3dObject), "AW: In Szenen sind nur 3D-Objekte erlaubt!");
//BFS01 if(pObj->ISA(E3dLight) && eLight <= Base3DLight7)
//BFS01 {
//BFS01 E3dLight* pLight = (E3dLight*)pObj;
//BFS01 bLampFound = TRUE;
//BFS01
//BFS01 // pLight in Base3D Konvention aktivieren
//BFS01 if(pLight->IsOn())
//BFS01 {
//BFS01 if(pLight->ISA(E3dPointLight))
//BFS01 {
//BFS01 // ist ein E3dPointLight
//BFS01 // Position, keine Richtung
//BFS01 B3dColor aCol(pLight->GetColor().GetColor());
//BFS01 aCol *= pLight->GetIntensity();
//BFS01 aLightGroup.SetIntensity(aCol, Base3DMaterialDiffuse, eLight);
//BFS01 aLightGroup.SetIntensity(Color(COL_WHITE), Base3DMaterialSpecular, eLight);
//BFS01 Vector3D aPos = pLight->GetPosition();
//BFS01 aLightGroup.SetPosition(aPos, eLight);
//BFS01
//BFS01 // Lichtquelle einschalten
//BFS01 aLightGroup.Enable(TRUE, eLight);
//BFS01
//BFS01 // Naechstes Licht in Base3D
//BFS01 eLight = (Base3DLightNumber)(eLight + 1);
//BFS01 }
//BFS01 else if(pLight->ISA(E3dDistantLight))
//BFS01 {
//BFS01 // ist ein E3dDistantLight
//BFS01 // Richtung, keine Position
//BFS01 B3dColor aCol(pLight->GetColor().GetColor());
//BFS01 aCol *= pLight->GetIntensity();
//BFS01 aLightGroup.SetIntensity(aCol, Base3DMaterialDiffuse, eLight);
//BFS01 aLightGroup.SetIntensity(Color(COL_WHITE), Base3DMaterialSpecular, eLight);
//BFS01 Vector3D aDir = ((E3dDistantLight *)pLight)->GetDirection();
//BFS01 aLightGroup.SetDirection(aDir, eLight);
//BFS01
//BFS01 // Lichtquelle einschalten
//BFS01 aLightGroup.Enable(TRUE, eLight);
//BFS01
//BFS01 // Naechstes Licht in Base3D
//BFS01 eLight = (Base3DLightNumber)(eLight + 1);
//BFS01 }
//BFS01 else
//BFS01 {
//BFS01 // nur ein E3dLight, gibt ein
//BFS01 // ambientes licht, auf globales aufaddieren
//BFS01 B3dColor aCol(pLight->GetColor().GetColor());
//BFS01 aCol *= pLight->GetIntensity();
//BFS01 aCol += (const B3dColor &)aLightGroup.GetGlobalAmbientLight();
//BFS01 aLightGroup.SetGlobalAmbientLight(aCol);
//BFS01 }
//BFS01 }
//BFS01 }
//BFS01 }
//BFS01
//BFS01 // Alle anderen Lichter ausschalten
//BFS01 while(eLight <= Base3DLight7)
//BFS01 {
//BFS01 aLightGroup.Enable(FALSE, eLight);
//BFS01 eLight = (Base3DLightNumber)(eLight + 1);
//BFS01 }
//BFS01 }
//BFS01
//BFS01 // Beleuchtung einschalten, falls Lampen vorhanden
//BFS01 aLightGroup.EnableLighting(bLampFound);
//BFS01}
/*************************************************************************
|*
|* Lichter zaehlen
|*
\************************************************************************/
//BFS01UINT16 E3dScene::CountNumberOfLights()
//BFS01{
//BFS01 UINT16 nNumLights = 0;
//BFS01
//BFS01 SdrObjList* pSubList = GetSubList();
//BFS01 if(pSubList)
//BFS01 {
//BFS01 SdrObjListIter a3DIterator(*pSubList, IM_DEEPWITHGROUPS);
//BFS01 while ( a3DIterator.IsMore() )
//BFS01 {
//BFS01 E3dObject* pObj = (E3dObject*) a3DIterator.Next();
//BFS01 DBG_ASSERT(pObj->ISA(E3dObject), "AW: In Szenen sind nur 3D-Objekte erlaubt!");
//BFS01 if(pObj->ISA(E3dLight))
//BFS01 {
//BFS01 // Zaehlen...
//BFS01 nNumLights++;
//BFS01 }
//BFS01 }
//BFS01 }
//BFS01 return nNumLights;
//BFS01}
/************************************************************************* /*************************************************************************
|* |*
|* SnapRect berechnen |* SnapRect berechnen
...@@ -1612,17 +1239,17 @@ BOOL E3dScene::IsBreakObjPossible() ...@@ -1612,17 +1239,17 @@ BOOL E3dScene::IsBreakObjPossible()
return TRUE; return TRUE;
} }
Vector3D E3dScene::GetShadowPlaneDirection() const basegfx::B3DVector E3dScene::GetShadowPlaneDirection() const
{ {
double fWink = (double)GetShadowSlant() * F_PI180; double fWink = (double)GetShadowSlant() * F_PI180;
Vector3D aShadowPlaneDir(0.0, sin(fWink), cos(fWink)); basegfx::B3DVector aShadowPlaneDir(0.0, sin(fWink), cos(fWink));
aShadowPlaneDir.Normalize(); aShadowPlaneDir.normalize();
return aShadowPlaneDir; return aShadowPlaneDir;
} }
void E3dScene::SetShadowPlaneDirection(const Vector3D& rVec) void E3dScene::SetShadowPlaneDirection(const basegfx::B3DVector& rVec)
{ {
UINT16 nSceneShadowSlant = (UINT16)((atan2(rVec.Y(), rVec.Z()) / F_PI180) + 0.5); UINT16 nSceneShadowSlant = (UINT16)((atan2(rVec.getY(), rVec.getZ()) / F_PI180) + 0.5);
GetProperties().SetObjectItemDirect(Svx3DShadowSlantItem(nSceneShadowSlant)); GetProperties().SetObjectItemDirect(Svx3DShadowSlantItem(nSceneShadowSlant));
} }
...@@ -1668,81 +1295,84 @@ sal_uInt32 E3dScene::HitTest(const Point& rHitTestPosition, ::std::vector< SdrOb ...@@ -1668,81 +1295,84 @@ sal_uInt32 E3dScene::HitTest(const Point& rHitTestPosition, ::std::vector< SdrOb
if(pObj->ISA(E3dCompoundObject)) if(pObj->ISA(E3dCompoundObject))
{ {
E3dCompoundObject* pCompoundObj = (E3dCompoundObject*)pObj;
// get HitLine in local 3D ObjectKoordinates // get HitLine in local 3D ObjectKoordinates
Matrix4D mTransform = ((E3dCompoundObject*)pObj)->GetFullTransform(); basegfx::B3DHomMatrix mTransform = pCompoundObj->GetFullTransform();
GetCameraSet().SetObjectTrans(mTransform); GetCameraSet().SetObjectTrans(mTransform);
// create HitPoint Front und Back, transform to local object coordinates // create HitPoint Front und Back, transform to local object coordinates
Vector3D aFront(rHitTestPosition.X(), rHitTestPosition.Y(), 0.0); basegfx::B3DPoint aFront(rHitTestPosition.X(), rHitTestPosition.Y(), 0.0);
Vector3D aBack(rHitTestPosition.X(), rHitTestPosition.Y(), ZBUFFER_DEPTH_RANGE); basegfx::B3DPoint aBack(rHitTestPosition.X(), rHitTestPosition.Y(), ZBUFFER_DEPTH_RANGE);
aFront = GetCameraSet().ViewToObjectCoor(aFront); aFront = GetCameraSet().ViewToObjectCoor(aFront);
aBack = GetCameraSet().ViewToObjectCoor(aBack); aBack = GetCameraSet().ViewToObjectCoor(aBack);
// make BoundVolume HitTest for speedup first // make BoundVolume HitTest for speedup first
const Volume3D& rBoundVol = ((E3dCompoundObject*)pObj)->GetBoundVolume(); const Volume3D& rBoundVol = pCompoundObj->GetBoundVolume();
if(rBoundVol.IsValid()) if(!rBoundVol.isEmpty())
{ {
double fXMax = aFront.X(); double fXMax(aFront.getX());
double fXMin = aBack.X(); double fXMin(aBack.getX());
if(fXMax < fXMin) if(fXMax < fXMin)
{ {
fXMax = aBack.X(); fXMax = aBack.getX();
fXMin = aFront.X(); fXMin = aFront.getX();
} }
if(rBoundVol.MinVec().X() <= fXMax && rBoundVol.MaxVec().X() >= fXMin) if(rBoundVol.getMinX() <= fXMax && rBoundVol.getMaxX() >= fXMin)
{ {
double fYMax = aFront.Y(); double fYMax(aFront.getY());
double fYMin = aBack.Y(); double fYMin(aBack.getY());
if(fYMax < fYMin) if(fYMax < fYMin)
{ {
fYMax = aBack.Y(); fYMax = aBack.getY();
fYMin = aFront.Y(); fYMin = aFront.getY();
} }
if(rBoundVol.MinVec().Y() <= fYMax && rBoundVol.MaxVec().Y() >= fYMin) if(rBoundVol.getMinY() <= fYMax && rBoundVol.getMaxY() >= fYMin)
{ {
double fZMax = aFront.Z(); double fZMax(aFront.getZ());
double fZMin = aBack.Z(); double fZMin(aBack.getZ());
if(fZMax < fZMin) if(fZMax < fZMin)
{ {
fZMax = aBack.Z(); fZMax = aBack.getZ();
fZMin = aFront.Z(); fZMin = aFront.getZ();
} }
if(rBoundVol.MinVec().Z() <= fZMax && rBoundVol.MaxVec().Z() >= fZMin) if(rBoundVol.getMinZ() <= fZMax && rBoundVol.getMaxZ() >= fZMin)
{ {
// BoundVol is hit, get geometry cuts now // BoundVol is hit, get geometry cuts now
Vector3DVector aParameter; ::std::vector< basegfx::B3DPoint > aParameter;
B3dGeometry& rGeometry = ((E3dCompoundObject*)pObj)->GetDisplayGeometry(); const B3dGeometry& rGeometry = pCompoundObj->GetDisplayGeometry();
rGeometry.GetAllCuts(aParameter, aFront, aBack); rGeometry.GetAllCuts(aParameter, aFront, aBack);
if(aParameter.size()) if(aParameter.size())
{ {
// take first cut as base, use Z-Coor in ViewCoor (0 ..ZBUFFER_DEPTH_RANGE) // take first cut as base, use Z-Coor in ViewCoor (0 ..ZBUFFER_DEPTH_RANGE)
ImplPairDephAndObject aTempResult; ImplPairDephAndObject aTempResult;
Vector3D aTempVector(aParameter[0]); basegfx::B3DPoint aTempVector(aParameter[0]);
aTempVector = GetCameraSet().ObjectToViewCoor(aTempVector); aTempVector = GetCameraSet().ObjectToViewCoor(aTempVector);
aTempResult.pObject = pObj; aTempResult.pObject = pCompoundObj;
aTempResult.fDepth = aTempVector.Z(); aTempResult.fDepth = aTempVector.getZ();
// look for cut points in front of the first one // look for cut points in front of the first one
Vector3DVector::iterator aIterator2(aParameter.begin()); ::std::vector< basegfx::B3DPoint >::iterator aIterator2(aParameter.begin());
aIterator2++; aIterator2++;
for(;aIterator2 != aParameter.end(); aIterator2++) for(;aIterator2 != aParameter.end(); aIterator2++)
{ {
aTempVector = GetCameraSet().ObjectToViewCoor(*aIterator2); basegfx::B3DPoint aTempVector2(*aIterator2);
aTempVector2 = GetCameraSet().ObjectToViewCoor(aTempVector2);
// use the smallest one // use the smallest one
if(aTempVector.Z() < aTempResult.fDepth) if(aTempVector2.getZ() < aTempResult.fDepth)
{ {
aTempResult.fDepth = aTempVector.Z(); aTempResult.fDepth = aTempVector2.getZ();
} }
} }
...@@ -1777,4 +1407,50 @@ sal_uInt32 E3dScene::HitTest(const Point& rHitTestPosition, ::std::vector< SdrOb ...@@ -1777,4 +1407,50 @@ sal_uInt32 E3dScene::HitTest(const Point& rHitTestPosition, ::std::vector< SdrOb
return nRetval; return nRetval;
} }
basegfx::B2DPolyPolygon E3dScene::TakeCreatePoly(const SdrDragStat& /*rDrag*/) const
{
return TakeXorPoly(sal_True);
}
FASTBOOL E3dScene::BegCreate(SdrDragStat& rStat)
{
rStat.SetOrtho4Possible();
Rectangle aRect1(rStat.GetStart(), rStat.GetNow());
aRect1.Justify();
rStat.SetActionRect(aRect1);
NbcSetSnapRect(aRect1);
return TRUE;
}
FASTBOOL E3dScene::MovCreate(SdrDragStat& rStat)
{
Rectangle aRect1;
rStat.TakeCreateRect(aRect1);
aRect1.Justify();
rStat.SetActionRect(aRect1);
NbcSetSnapRect(aRect1);
bBoundRectDirty=TRUE;
bSnapRectDirty=TRUE;
return TRUE;
}
FASTBOOL E3dScene::EndCreate(SdrDragStat& rStat, SdrCreateCmd eCmd)
{
Rectangle aRect1;
rStat.TakeCreateRect(aRect1);
aRect1.Justify();
NbcSetSnapRect(aRect1);
SetRectsDirty();
return (eCmd==SDRCREATE_FORCEEND || rStat.GetPointAnz()>=2);
}
FASTBOOL E3dScene::BckCreate(SdrDragStat& /*rStat*/)
{
return FALSE;
}
void E3dScene::BrkCreate(SdrDragStat& /*rStat*/)
{
}
// eof // eof
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment