mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-01-20 12:44:46 +00:00
328 lines
12 KiB
C++
328 lines
12 KiB
C++
//-----------------------------------------------------------------------------
|
|
// Copyright (c) 2012 GarageGames, LLC
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
// of this software and associated documentation files (the "Software"), to
|
|
// deal in the Software without restriction, including without limitation the
|
|
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
// sell copies of the Software, and to permit persons to whom the Software is
|
|
// furnished to do so, subject to the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be included in
|
|
// all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
// IN THE SOFTWARE.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#include "scene/sgUtil.h"
|
|
#include "math/mRect.h"
|
|
#include "math/mMatrix.h"
|
|
#include "math/mPlane.h"
|
|
|
|
namespace {
|
|
|
|
// Static state for sgComputeNewFrustum
|
|
//
|
|
Point3F sgCamPoint;
|
|
MatrixF sgWSToOSMatrix;
|
|
MatrixF sgProjMatrix;
|
|
PlaneF sgOSPlaneFar;
|
|
PlaneF sgOSPlaneXMin;
|
|
PlaneF sgOSPlaneXMax;
|
|
PlaneF sgOSPlaneYMin;
|
|
PlaneF sgOSPlaneYMax;
|
|
|
|
|
|
void clipToPlane(Point3F* points, U32& rNumPoints, const PlaneF& rPlane)
|
|
{
|
|
S32 start = -1;
|
|
for (U32 i = 0; i < rNumPoints; i++) {
|
|
if (rPlane.whichSide(points[i]) == PlaneF::Front) {
|
|
start = i;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Nothing was in front of the plane...
|
|
if (start == -1) {
|
|
rNumPoints = 0;
|
|
return;
|
|
}
|
|
|
|
Point3F finalPoints[128];
|
|
U32 numFinalPoints = 0;
|
|
|
|
U32 baseStart = start;
|
|
U32 end = (start + 1) % rNumPoints;
|
|
|
|
while (end != baseStart) {
|
|
const Point3F& rStartPoint = points[start];
|
|
const Point3F& rEndPoint = points[end];
|
|
|
|
PlaneF::Side fSide = rPlane.whichSide(rStartPoint);
|
|
PlaneF::Side eSide = rPlane.whichSide(rEndPoint);
|
|
|
|
S32 code = fSide * 3 + eSide;
|
|
switch (code) {
|
|
case 4: // f f
|
|
case 3: // f o
|
|
case 1: // o f
|
|
case 0: // o o
|
|
// No Clipping required
|
|
finalPoints[numFinalPoints++] = points[start];
|
|
start = end;
|
|
end = (end + 1) % rNumPoints;
|
|
break;
|
|
|
|
|
|
case 2: { // f b
|
|
// In this case, we emit the front point, Insert the intersection,
|
|
// and advancing to point to first point that is in front or on...
|
|
//
|
|
finalPoints[numFinalPoints++] = points[start];
|
|
|
|
Point3F vector = rEndPoint - rStartPoint;
|
|
F32 t = -(rPlane.distToPlane(rStartPoint) / mDot(rPlane, vector));
|
|
|
|
Point3F intersection = rStartPoint + (vector * t);
|
|
finalPoints[numFinalPoints++] = intersection;
|
|
|
|
U32 endSeek = (end + 1) % rNumPoints;
|
|
while (rPlane.whichSide(points[endSeek]) == PlaneF::Back)
|
|
endSeek = (endSeek + 1) % rNumPoints;
|
|
|
|
end = endSeek;
|
|
start = (end + (rNumPoints - 1)) % rNumPoints;
|
|
|
|
const Point3F& rNewStartPoint = points[start];
|
|
const Point3F& rNewEndPoint = points[end];
|
|
|
|
vector = rNewEndPoint - rNewStartPoint;
|
|
t = -(rPlane.distToPlane(rNewStartPoint) / mDot(rPlane, vector));
|
|
|
|
intersection = rNewStartPoint + (vector * t);
|
|
points[start] = intersection;
|
|
}
|
|
break;
|
|
|
|
case -1: {// o b
|
|
// In this case, we emit the front point, and advance to point to first
|
|
// point that is in front or on...
|
|
//
|
|
finalPoints[numFinalPoints++] = points[start];
|
|
|
|
U32 endSeek = (end + 1) % rNumPoints;
|
|
while (rPlane.whichSide(points[endSeek]) == PlaneF::Back)
|
|
endSeek = (endSeek + 1) % rNumPoints;
|
|
|
|
end = endSeek;
|
|
start = (end + (rNumPoints - 1)) % rNumPoints;
|
|
|
|
const Point3F& rNewStartPoint = points[start];
|
|
const Point3F& rNewEndPoint = points[end];
|
|
|
|
Point3F vector = rNewEndPoint - rNewStartPoint;
|
|
F32 t = -(rPlane.distToPlane(rNewStartPoint) / mDot(rPlane, vector));
|
|
|
|
Point3F intersection = rNewStartPoint + (vector * t);
|
|
points[start] = intersection;
|
|
}
|
|
break;
|
|
|
|
case -2: // b f
|
|
case -3: // b o
|
|
case -4: // b b
|
|
// In the algorithm used here, this should never happen...
|
|
AssertISV(false, "SGUtil::clipToPlane: error in polygon clipper");
|
|
break;
|
|
|
|
default:
|
|
AssertFatal(false, "SGUtil::clipToPlane: bad outcode");
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
// Emit the last point.
|
|
finalPoints[numFinalPoints++] = points[start];
|
|
AssertFatal(numFinalPoints >= 3, avar("Error, this shouldn't happen! Invalid winding in clipToPlane: %d", numFinalPoints));
|
|
|
|
// Copy the new rWinding, and we're set!
|
|
//
|
|
dMemcpy(points, finalPoints, numFinalPoints * sizeof(Point3F));
|
|
rNumPoints = numFinalPoints;
|
|
AssertISV(rNumPoints <= 128, "MaxWindingPoints exceeded in scenegraph. Fatal error.");
|
|
}
|
|
|
|
|
|
void fixupViewport(const F64* oldFrustum,
|
|
const RectI& oldViewport,
|
|
F64* newFrustum,
|
|
RectI& newViewport)
|
|
{
|
|
F64 widthV = newFrustum[1] - newFrustum[0];
|
|
F64 heightV = newFrustum[3] - newFrustum[2];
|
|
|
|
F64 fx0 = (newFrustum[0] - oldFrustum[0]) / (oldFrustum[1] - oldFrustum[0]);
|
|
F64 fx1 = (oldFrustum[1] - newFrustum[1]) / (oldFrustum[1] - oldFrustum[0]);
|
|
|
|
F64 dV0 = F64(oldViewport.point.x) + fx0 * F64(oldViewport.extent.x);
|
|
F64 dV1 = F64(oldViewport.point.x +
|
|
oldViewport.extent.x) - fx1 * F64(oldViewport.extent.x);
|
|
|
|
F64 fdV0 = mFloor(dV0);
|
|
F64 cdV1 = mCeil(dV1);
|
|
|
|
F64 new0 = newFrustum[0] - ((dV0 - fdV0) * (widthV / F64(oldViewport.extent.x)));
|
|
F64 new1 = newFrustum[1] + ((cdV1 - dV1) * (widthV / F64(oldViewport.extent.x)));
|
|
|
|
newFrustum[0] = new0;
|
|
newFrustum[1] = new1;
|
|
|
|
newViewport.point.x = S32(fdV0);
|
|
newViewport.extent.x = S32(cdV1) - newViewport.point.x;
|
|
|
|
F64 fy0 = (oldFrustum[3] - newFrustum[3]) / (oldFrustum[3] - oldFrustum[2]);
|
|
F64 fy1 = (newFrustum[2] - oldFrustum[2]) / (oldFrustum[3] - oldFrustum[2]);
|
|
|
|
dV0 = F64(oldViewport.point.y) + fy0 * F64(oldViewport.extent.y);
|
|
dV1 = F64(oldViewport.point.y + oldViewport.extent.y) - fy1 * F64(oldViewport.extent.y);
|
|
fdV0 = mFloor(dV0);
|
|
cdV1 = mCeil(dV1);
|
|
|
|
new0 = newFrustum[2] - ((cdV1 - dV1) * (heightV / F64(oldViewport.extent.y)));
|
|
new1 = newFrustum[3] + ((dV0 - fdV0) * (heightV / F64(oldViewport.extent.y)));
|
|
newFrustum[2] = new0;
|
|
newFrustum[3] = new1;
|
|
|
|
newViewport.point.y = S32(fdV0);
|
|
newViewport.extent.y = S32(cdV1) - newViewport.point.y;
|
|
}
|
|
|
|
bool projectClipAndBoundWinding(const SGWinding& rWinding, F64* pResult)
|
|
{
|
|
AssertFatal(rWinding.numPoints >= 3, "Error, that's not a winding!");
|
|
|
|
static Point3F windingPoints[128];
|
|
U32 i;
|
|
for (i = 0; i < rWinding.numPoints; i++)
|
|
windingPoints[i] = rWinding.points[i];
|
|
U32 numPoints = rWinding.numPoints;
|
|
|
|
clipToPlane(windingPoints, numPoints, sgOSPlaneFar);
|
|
if (numPoints != 0)
|
|
clipToPlane(windingPoints, numPoints, sgOSPlaneXMin);
|
|
if (numPoints != 0)
|
|
clipToPlane(windingPoints, numPoints, sgOSPlaneXMax);
|
|
if (numPoints != 0)
|
|
clipToPlane(windingPoints, numPoints, sgOSPlaneYMin);
|
|
if (numPoints != 0)
|
|
clipToPlane(windingPoints, numPoints, sgOSPlaneYMax);
|
|
|
|
if (numPoints == 0)
|
|
return false;
|
|
|
|
Point4F projPoint;
|
|
for (i = 0; i < numPoints; i++) {
|
|
projPoint.set(windingPoints[i].x, windingPoints[i].y, windingPoints[i].z, 1.0);
|
|
sgProjMatrix.mul(projPoint);
|
|
|
|
AssertFatal(projPoint.w != 0.0, "Error, that's bad! (Point projected with non-zero w.)");
|
|
projPoint.x /= projPoint.w;
|
|
projPoint.y /= projPoint.w;
|
|
|
|
if (projPoint.x < pResult[0])
|
|
pResult[0] = projPoint.x;
|
|
if (projPoint.x > pResult[1])
|
|
pResult[1] = projPoint.x;
|
|
if (projPoint.y < pResult[2])
|
|
pResult[2] = projPoint.y;
|
|
if (projPoint.y > pResult[3])
|
|
pResult[3] = projPoint.y;
|
|
}
|
|
|
|
if (pResult[0] < -1.0f) pResult[0] = -1.0f;
|
|
if (pResult[2] < -1.0f) pResult[2] = -1.0f;
|
|
if (pResult[1] > 1.0f) pResult[1] = 1.0f;
|
|
if (pResult[3] > 1.0f) pResult[3] = 1.0f;
|
|
|
|
return true;
|
|
}
|
|
|
|
} // namespace { }
|
|
|
|
|
|
//--------------------------------------------------------------------------
|
|
bool sgComputeNewFrustum(const Frustum &oldFrustum,
|
|
const F64 nearPlane,
|
|
const F64 farPlane,
|
|
const RectI& oldViewport,
|
|
const SGWinding* windings,
|
|
const U32 numWindings,
|
|
const MatrixF& modelview,
|
|
F64 *newFrustum,
|
|
RectI& newViewport,
|
|
const bool flippedMatrix)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
|
|
void sgComputeOSFrustumPlanes(const F64 frustumParameters[6],
|
|
const MatrixF& worldSpaceToObjectSpace,
|
|
const Point3F& wsCamPoint,
|
|
PlaneF& outFarPlane,
|
|
PlaneF& outXMinPlane,
|
|
PlaneF& outXMaxPlane,
|
|
PlaneF& outYMinPlane,
|
|
PlaneF& outYMaxPlane)
|
|
{
|
|
// Create the object space clipping planes...
|
|
Point3F ul(frustumParameters[0] * 1000.0, frustumParameters[4] * 1000.0, frustumParameters[3] * 1000.0);
|
|
Point3F ur(frustumParameters[1] * 1000.0, frustumParameters[4] * 1000.0, frustumParameters[3] * 1000.0);
|
|
Point3F ll(frustumParameters[0] * 1000.0, frustumParameters[4] * 1000.0, frustumParameters[2] * 1000.0);
|
|
Point3F lr(frustumParameters[1] * 1000.0, frustumParameters[4] * 1000.0, frustumParameters[2] * 1000.0);
|
|
Point3F farPlane(0, frustumParameters[5], 0);
|
|
|
|
worldSpaceToObjectSpace.mulP(ul);
|
|
worldSpaceToObjectSpace.mulP(ur);
|
|
worldSpaceToObjectSpace.mulP(ll);
|
|
worldSpaceToObjectSpace.mulP(lr);
|
|
worldSpaceToObjectSpace.mulP(farPlane);
|
|
|
|
outFarPlane.set(farPlane, wsCamPoint - farPlane);
|
|
outXMinPlane.set(wsCamPoint, ul, ll);
|
|
outXMaxPlane.set(wsCamPoint, lr, ur);
|
|
outYMinPlane.set(wsCamPoint, ur, ul);
|
|
outYMaxPlane.set(wsCamPoint, ll, lr);
|
|
}
|
|
|
|
// MM/JF: Added for mirrorSubObject fix.
|
|
void sgOrientClipPlanes(
|
|
PlaneF * planes,
|
|
const Point3F & camPos,
|
|
const Point3F & leftUp,
|
|
const Point3F & leftDown,
|
|
const Point3F & rightUp,
|
|
const Point3F & rightDown)
|
|
{
|
|
AssertFatal(planes, "orientClipPlanes: NULL planes ptr");
|
|
planes[0].set(camPos, leftUp, leftDown);
|
|
planes[1].set(camPos, rightUp, leftUp);
|
|
planes[2].set(camPos, rightDown, rightUp);
|
|
planes[3].set(camPos, leftDown, rightDown);
|
|
planes[4].set(leftUp, rightUp, rightDown);
|
|
|
|
// clip-planes through mirror portal are inverted
|
|
PlaneF plane(leftUp, rightUp, rightDown);
|
|
if(plane.whichSide(camPos) == PlaneF::Back)
|
|
for(U32 i = 0; i < 5; i++)
|
|
planes[i].invert();
|
|
}
|