456 lines
12 KiB
C++
456 lines
12 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* This file is part of the LibreOffice project.
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* This file incorporates work covered by the following license notice:
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed
|
|
* with this work for additional information regarding copyright
|
|
* ownership. The ASF licenses this file to you under the Apache
|
|
* License, Version 2.0 (the "License"); you may not use this file
|
|
* except in compliance with the License. You may obtain a copy of
|
|
* the License at http://www.apache.org/licenses/LICENSE-2.0 .
|
|
*/
|
|
|
|
#include <tools/b3dtrans.hxx>
|
|
|
|
#include <osl/diagnose.h>
|
|
|
|
// Near and far clipping planes
|
|
constexpr double gfNearBound = 0.001;
|
|
constexpr double gfFarBound = 1.001;
|
|
|
|
|
|
// B3dTransformationSet --------------------------------------------------------
|
|
// Transformations for all 3D output
|
|
|
|
B3dTransformationSet::B3dTransformationSet()
|
|
{
|
|
Reset();
|
|
}
|
|
|
|
B3dTransformationSet::~B3dTransformationSet()
|
|
{
|
|
}
|
|
|
|
void B3dTransformationSet::Orientation(basegfx::B3DHomMatrix& rTarget, const basegfx::B3DPoint& aVRP, basegfx::B3DVector aVPN, basegfx::B3DVector aVUP)
|
|
{
|
|
rTarget.translate( -aVRP.getX(), -aVRP.getY(), -aVRP.getZ());
|
|
aVUP.normalize();
|
|
aVPN.normalize();
|
|
basegfx::B3DVector aRx(aVUP);
|
|
basegfx::B3DVector aRy(aVPN);
|
|
aRx = aRx.getPerpendicular(aRy);
|
|
aRx.normalize();
|
|
aRy = aRy.getPerpendicular(aRx);
|
|
aRy.normalize();
|
|
basegfx::B3DHomMatrix aTemp;
|
|
aTemp.set(0, 0, aRx.getX());
|
|
aTemp.set(0, 1, aRx.getY());
|
|
aTemp.set(0, 2, aRx.getZ());
|
|
aTemp.set(1, 0, aRy.getX());
|
|
aTemp.set(1, 1, aRy.getY());
|
|
aTemp.set(1, 2, aRy.getZ());
|
|
aTemp.set(2, 0, aVPN.getX());
|
|
aTemp.set(2, 1, aVPN.getY());
|
|
aTemp.set(2, 2, aVPN.getZ());
|
|
rTarget *= aTemp;
|
|
}
|
|
|
|
void B3dTransformationSet::Frustum(basegfx::B3DHomMatrix& rTarget, double fLeft, double fRight, double fBottom, double fTop, double fNear, double fFar)
|
|
{
|
|
if(!(fNear > 0.0))
|
|
{
|
|
fNear = 0.001;
|
|
}
|
|
if(!(fFar > 0.0))
|
|
{
|
|
fFar = 1.0;
|
|
}
|
|
if(fNear == fFar)
|
|
{
|
|
fFar = fNear + 1.0;
|
|
}
|
|
if(fLeft == fRight)
|
|
{
|
|
fLeft -= 1.0;
|
|
fRight += 1.0;
|
|
}
|
|
if(fTop == fBottom)
|
|
{
|
|
fBottom -= 1.0;
|
|
fTop += 1.0;
|
|
}
|
|
basegfx::B3DHomMatrix aTemp;
|
|
|
|
aTemp.set(0, 0, 2.0 * fNear / (fRight - fLeft));
|
|
aTemp.set(1, 1, 2.0 * fNear / (fTop - fBottom));
|
|
aTemp.set(0, 2, (fRight + fLeft) / (fRight - fLeft));
|
|
aTemp.set(1, 2, (fTop + fBottom) / (fTop - fBottom));
|
|
aTemp.set(2, 2, -1.0 * ((fFar + fNear) / (fFar - fNear)));
|
|
aTemp.set(3, 2, -1.0);
|
|
aTemp.set(2, 3, -1.0 * ((2.0 * fFar * fNear) / (fFar - fNear)));
|
|
aTemp.set(3, 3, 0.0);
|
|
|
|
rTarget *= aTemp;
|
|
}
|
|
|
|
void B3dTransformationSet::Ortho(basegfx::B3DHomMatrix& rTarget,
|
|
double fLeft, double fRight, double fBottom, double fTop,
|
|
double fNear, double fFar)
|
|
{
|
|
if(fNear == fFar)
|
|
{
|
|
OSL_FAIL("Near and far clipping plane in Ortho definition are identical");
|
|
fFar = fNear + 1.0;
|
|
}
|
|
if(fLeft == fRight)
|
|
{
|
|
OSL_FAIL("Left and right in Ortho definition are identical");
|
|
fLeft -= 1.0;
|
|
fRight += 1.0;
|
|
}
|
|
if(fTop == fBottom)
|
|
{
|
|
OSL_FAIL("Top and bottom in Ortho definition are identical");
|
|
fBottom -= 1.0;
|
|
fTop += 1.0;
|
|
}
|
|
basegfx::B3DHomMatrix aTemp;
|
|
|
|
aTemp.set(0, 0, 2.0 / (fRight - fLeft));
|
|
aTemp.set(1, 1, 2.0 / (fTop - fBottom));
|
|
aTemp.set(2, 2, -1.0 * (2.0 / (fFar - fNear)));
|
|
aTemp.set(0, 3, -1.0 * ((fRight + fLeft) / (fRight - fLeft)));
|
|
aTemp.set(1, 3, -1.0 * ((fTop + fBottom) / (fTop - fBottom)));
|
|
aTemp.set(2, 3, -1.0 * ((fFar + fNear) / (fFar - fNear)));
|
|
|
|
rTarget *= aTemp;
|
|
}
|
|
|
|
/// reset values
|
|
void B3dTransformationSet::Reset()
|
|
{
|
|
// Reset matrices to identity matrices
|
|
maObjectTrans.identity();
|
|
PostSetObjectTrans();
|
|
|
|
Orientation(maOrientation);
|
|
PostSetOrientation();
|
|
|
|
maTexture.identity();
|
|
|
|
mfLeftBound = mfBottomBound = -1.0;
|
|
mfRightBound = mfTopBound = 1.0;
|
|
|
|
mfRatio = 0.0;
|
|
|
|
maViewportRectangle = tools::Rectangle(-1, -1, 2, 2);
|
|
maVisibleRectangle = maViewportRectangle;
|
|
|
|
mbPerspective = true;
|
|
|
|
mbProjectionValid = false;
|
|
|
|
CalcViewport();
|
|
}
|
|
|
|
/// Object transformation
|
|
void B3dTransformationSet::PostSetObjectTrans()
|
|
{
|
|
// Assign and compute inverse
|
|
maInvObjectTrans = maObjectTrans;
|
|
maInvObjectTrans.invert();
|
|
}
|
|
|
|
void B3dTransformationSet::SetOrientation(const basegfx::B3DPoint& rVRP, const basegfx::B3DVector& rVPN, const basegfx::B3DVector& rVUP)
|
|
{
|
|
maOrientation.identity();
|
|
Orientation(maOrientation, rVRP, rVPN, rVUP);
|
|
|
|
PostSetOrientation();
|
|
}
|
|
|
|
void B3dTransformationSet::PostSetOrientation()
|
|
{
|
|
// Assign and compute inverse
|
|
maInvOrientation = maOrientation;
|
|
maInvOrientation.invert();
|
|
}
|
|
|
|
/// Projections for transformations
|
|
void B3dTransformationSet::SetProjection(const basegfx::B3DHomMatrix& mProject)
|
|
{
|
|
maProjection = mProject;
|
|
PostSetProjection();
|
|
}
|
|
|
|
const basegfx::B3DHomMatrix& B3dTransformationSet::GetProjection()
|
|
{
|
|
if(!mbProjectionValid)
|
|
CalcViewport();
|
|
return maProjection;
|
|
}
|
|
|
|
void B3dTransformationSet::PostSetProjection()
|
|
{
|
|
// Assign and compute inverse
|
|
maInvProjection = GetProjection();
|
|
maInvProjection.invert();
|
|
}
|
|
|
|
/// Transformations for viewport
|
|
void B3dTransformationSet::CalcViewport()
|
|
{
|
|
// Parameters for projection
|
|
double fLeft(mfLeftBound);
|
|
double fRight(mfRightBound);
|
|
double fBottom(mfBottomBound);
|
|
double fTop(mfTopBound);
|
|
|
|
// Adjust projection to aspect ratio, if set
|
|
if(GetRatio() != 0.0)
|
|
{
|
|
// Compute current aspect ratio of boundaries
|
|
double fBoundWidth = static_cast<double>(maViewportRectangle.GetWidth() + 1);
|
|
double fBoundHeight = static_cast<double>(maViewportRectangle.GetHeight() + 1);
|
|
double fActRatio = 1;
|
|
double fFactor;
|
|
|
|
if(fBoundWidth != 0.0)
|
|
fActRatio = fBoundHeight / fBoundWidth;
|
|
// FIXME else in this case has a lot of problems, should this return.
|
|
|
|
// scale down larger part
|
|
if(fActRatio > mfRatio)
|
|
{
|
|
// scale down Y
|
|
fFactor = fActRatio;
|
|
fTop *= fFactor;
|
|
fBottom *= fFactor;
|
|
}
|
|
else
|
|
{
|
|
// scale down X
|
|
fFactor = 1.0 / fActRatio;
|
|
fRight *= fFactor;
|
|
fLeft *= fFactor;
|
|
}
|
|
}
|
|
|
|
// Do projection and object areas overlap?
|
|
maSetBound = maViewportRectangle;
|
|
|
|
// Reset projection with new values
|
|
basegfx::B3DHomMatrix aNewProjection;
|
|
|
|
// #i36281#
|
|
// OpenGL needs a little more rough additional size to not let
|
|
// the front face vanish. Changed from SMALL_DVALUE to 0.000001,
|
|
// which is 1/10000th, compared with 1/tenth of a million from SMALL_DVALUE.
|
|
const double fDistPart((gfFarBound - gfNearBound) * 0.0001);
|
|
|
|
// To avoid critical clipping, set Near & Far generously
|
|
if(mbPerspective)
|
|
{
|
|
Frustum(aNewProjection, fLeft, fRight, fBottom, fTop, gfNearBound - fDistPart, gfFarBound + fDistPart);
|
|
}
|
|
else
|
|
{
|
|
Ortho(aNewProjection, fLeft, fRight, fBottom, fTop, gfNearBound - fDistPart, gfFarBound + fDistPart);
|
|
}
|
|
|
|
// Set to true to guarantee loop termination
|
|
mbProjectionValid = true;
|
|
|
|
// set new projection
|
|
SetProjection(aNewProjection);
|
|
|
|
// fill parameters for ViewportTransformation
|
|
// Translation
|
|
maTranslate.setX(static_cast<double>(maSetBound.Left()) + ((maSetBound.GetWidth() - 1) / 2.0));
|
|
maTranslate.setY(static_cast<double>(maSetBound.Top()) + ((maSetBound.GetHeight() - 1) / 2.0));
|
|
maTranslate.setZ(ZBUFFER_DEPTH_RANGE / 2.0);
|
|
|
|
// Scaling
|
|
maScale.setX((maSetBound.GetWidth() - 1) / 2.0);
|
|
maScale.setY((maSetBound.GetHeight() - 1) / -2.0);
|
|
maScale.setZ(ZBUFFER_DEPTH_RANGE / 2.0);
|
|
}
|
|
|
|
void B3dTransformationSet::SetRatio(double fNew)
|
|
{
|
|
if(mfRatio != fNew)
|
|
{
|
|
mfRatio = fNew;
|
|
mbProjectionValid = false;
|
|
}
|
|
}
|
|
|
|
void B3dTransformationSet::SetDeviceRectangle(double fL, double fR, double fB, double fT)
|
|
{
|
|
if(fL != mfLeftBound || fR != mfRightBound || fB != mfBottomBound || fT != mfTopBound)
|
|
{
|
|
mfLeftBound = fL;
|
|
mfRightBound = fR;
|
|
mfBottomBound = fB;
|
|
mfTopBound = fT;
|
|
|
|
mbProjectionValid = false;
|
|
|
|
// Broadcast changes
|
|
DeviceRectangleChange();
|
|
}
|
|
}
|
|
|
|
void B3dTransformationSet::DeviceRectangleChange()
|
|
{
|
|
}
|
|
|
|
void B3dTransformationSet::SetPerspective(bool bNew)
|
|
{
|
|
if(mbPerspective != bNew)
|
|
{
|
|
mbPerspective = bNew;
|
|
mbProjectionValid = false;
|
|
}
|
|
}
|
|
|
|
void B3dTransformationSet::SetViewportRectangle(tools::Rectangle const & rRect, tools::Rectangle const & rVisible)
|
|
{
|
|
if(rRect != maViewportRectangle || rVisible != maVisibleRectangle)
|
|
{
|
|
maViewportRectangle = rRect;
|
|
maVisibleRectangle = rVisible;
|
|
|
|
mbProjectionValid = false;
|
|
}
|
|
}
|
|
|
|
// direct access to various transformations
|
|
|
|
basegfx::B3DPoint B3dTransformationSet::WorldToEyeCoor(const basegfx::B3DPoint& rVec)
|
|
{
|
|
basegfx::B3DPoint aVec(rVec);
|
|
aVec *= maOrientation;
|
|
return aVec;
|
|
}
|
|
|
|
basegfx::B3DPoint B3dTransformationSet::EyeToWorldCoor(const basegfx::B3DPoint& rVec)
|
|
{
|
|
basegfx::B3DPoint aVec(rVec);
|
|
aVec *= maInvOrientation;
|
|
return aVec;
|
|
}
|
|
|
|
// B3dViewport -----------------------------------------------------------------
|
|
|
|
B3dViewport::B3dViewport()
|
|
: aVRP(0, 0, 0),
|
|
aVPN(0, 0, 1),
|
|
aVUV(0, 1, 0)
|
|
{
|
|
CalcOrientation();
|
|
}
|
|
|
|
B3dViewport::~B3dViewport()
|
|
{
|
|
}
|
|
|
|
void B3dViewport::SetVUV(const basegfx::B3DVector& rNewVUV)
|
|
{
|
|
aVUV = rNewVUV;
|
|
CalcOrientation();
|
|
}
|
|
|
|
void B3dViewport::SetViewportValues(
|
|
const basegfx::B3DPoint& rNewVRP,
|
|
const basegfx::B3DVector& rNewVPN,
|
|
const basegfx::B3DVector& rNewVUV)
|
|
{
|
|
aVRP = rNewVRP;
|
|
aVPN = rNewVPN;
|
|
aVUV = rNewVUV;
|
|
CalcOrientation();
|
|
}
|
|
|
|
void B3dViewport::CalcOrientation()
|
|
{
|
|
SetOrientation(aVRP, aVPN, aVUV);
|
|
}
|
|
|
|
// B3dCamera -------------------------------------------------------------------
|
|
|
|
B3dCamera::B3dCamera(
|
|
const basegfx::B3DPoint& rPos, const basegfx::B3DVector& rLkAt,
|
|
double fFocLen, double fBnkAng)
|
|
: aPosition(rPos),
|
|
aLookAt(rLkAt),
|
|
fFocalLength(fFocLen),
|
|
fBankAngle(fBnkAng)
|
|
{
|
|
CalcNewViewportValues();
|
|
}
|
|
|
|
B3dCamera::~B3dCamera()
|
|
{
|
|
}
|
|
|
|
void B3dCamera::DeviceRectangleChange()
|
|
{
|
|
// call parent
|
|
B3dViewport::DeviceRectangleChange();
|
|
|
|
// react to changes
|
|
CalcNewViewportValues();
|
|
}
|
|
|
|
void B3dCamera::CalcNewViewportValues()
|
|
{
|
|
basegfx::B3DVector aNewVPN(aPosition - aLookAt);
|
|
|
|
basegfx::B3DVector aNewVUV(0.0, 1.0, 0.0);
|
|
if(aNewVPN.getLength() < aNewVPN.getY())
|
|
aNewVUV.setX(0.5);
|
|
|
|
aNewVUV.normalize();
|
|
aNewVPN.normalize();
|
|
|
|
basegfx::B3DVector aNewToTheRight = aNewVPN.getPerpendicular(aNewVUV);
|
|
aNewToTheRight.normalize();
|
|
aNewVUV = aNewToTheRight.getPerpendicular(aNewVPN);
|
|
aNewVUV.normalize();
|
|
|
|
SetViewportValues(aPosition, aNewVPN, aNewVUV);
|
|
CalcFocalLength();
|
|
|
|
if(fBankAngle != 0.0)
|
|
{
|
|
basegfx::B3DHomMatrix aRotMat;
|
|
aRotMat.rotate(0.0, 0.0, fBankAngle);
|
|
basegfx::B3DVector aUp(0.0, 1.0, 0.0);
|
|
aUp *= aRotMat;
|
|
aUp = EyeToWorldCoor(aUp);
|
|
aUp.normalize();
|
|
SetVUV(aUp);
|
|
}
|
|
}
|
|
|
|
void B3dCamera::CalcFocalLength()
|
|
{
|
|
double fWidth = GetDeviceRectangleWidth();
|
|
|
|
// Adjust focal length based on given position
|
|
basegfx::B3DPoint aOldPosition = WorldToEyeCoor({});
|
|
if(fWidth != 0.0)
|
|
fFocalLength = aOldPosition.getZ() / fWidth * 35.0;
|
|
if(fFocalLength < 5.0)
|
|
fFocalLength = 5.0;
|
|
}
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|