forked from 0ad/0ad
184 lines
6.7 KiB
C++
184 lines
6.7 KiB
C++
/* Copyright (C) 2012 Wildfire Games.
|
|
* This file is part of 0 A.D.
|
|
*
|
|
* 0 A.D. is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* 0 A.D. is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with 0 A.D. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "lib/self_test.h"
|
|
|
|
#include "maths/Brush.h"
|
|
#include "maths/BoundingBoxAligned.h"
|
|
#include "graphics/Frustum.h"
|
|
|
|
class TestBrush : public CxxTest::TestSuite
|
|
{
|
|
public:
|
|
void setUp()
|
|
{
|
|
CxxTest::setAbortTestOnFail(true);
|
|
}
|
|
|
|
void tearDown()
|
|
{
|
|
|
|
}
|
|
|
|
void test_slice_empty_brush()
|
|
{
|
|
// verifies that the result of slicing an empty bound with a plane yields an empty bound
|
|
CBrush brush;
|
|
CPlane plane(CVector4D(0, 0, -1, 0.5f)); // can be anything, really
|
|
|
|
CBrush result;
|
|
brush.Slice(plane, result);
|
|
TS_ASSERT(brush.IsEmpty());
|
|
}
|
|
|
|
void test_slice_plane_simple()
|
|
{
|
|
// slice a 1x1x1 cube vertically down the middle at z = 0.5, with the plane normal pointing towards the negative
|
|
// end of the Z axis (i.e., anything with Z lower than 0.5 is considered 'in front of' the plane and is kept)
|
|
CPlane plane(CVector4D(0, 0, -1, 0.5f));
|
|
CBrush brush(CBoundingBoxAligned(CVector3D(0,0,0), CVector3D(1,1,1)));
|
|
|
|
CBrush result;
|
|
brush.Slice(plane, result);
|
|
|
|
// verify that the resulting brush consists of exactly our 8 expected, unique vertices
|
|
TS_ASSERT_EQUALS((size_t)8, result.GetVertices().size());
|
|
size_t LBF = GetUniqueVertexIndex(result, CVector3D(0, 0, 0)); // left-bottom-front <=> XYZ
|
|
size_t RBF = GetUniqueVertexIndex(result, CVector3D(1, 0, 0)); // right-bottom-front
|
|
size_t RBB = GetUniqueVertexIndex(result, CVector3D(1, 0, 0.5f)); // right-bottom-back
|
|
size_t LBB = GetUniqueVertexIndex(result, CVector3D(0, 0, 0.5f)); // etc.
|
|
size_t LTF = GetUniqueVertexIndex(result, CVector3D(0, 1, 0));
|
|
size_t RTF = GetUniqueVertexIndex(result, CVector3D(1, 1, 0));
|
|
size_t RTB = GetUniqueVertexIndex(result, CVector3D(1, 1, 0.5f));
|
|
size_t LTB = GetUniqueVertexIndex(result, CVector3D(0, 1, 0.5f));
|
|
|
|
// verify that the brush contains the six expected planes (one of which is the slicing plane)
|
|
VerifyFacePresent(result, 5, LBF, RBF, RBB, LBB, LBF); // bottom face
|
|
VerifyFacePresent(result, 5, LTF, RTF, RTB, LTB, LTF); // top face
|
|
VerifyFacePresent(result, 5, LBF, LBB, LTB, LTF, LBF); // left face
|
|
VerifyFacePresent(result, 5, RBF, RBB, RTB, RTF, RBF); // right face
|
|
VerifyFacePresent(result, 5, LBF, RBF, RTF, LTF, LBF); // front face
|
|
VerifyFacePresent(result, 5, LBB, RBB, RTB, LTB, LBB); // back face
|
|
}
|
|
|
|
void test_slice_plane_behind_brush()
|
|
{
|
|
// slice the (0,0,0) to (1,1,1) cube by the plane z = 1.5, with the plane normal pointing towards the negative
|
|
// end of the Z axis (i.e. the entire cube is 'in front of' the plane and should be kept)
|
|
CPlane plane(CVector4D(0, 0, -1, 1.5f));
|
|
CBrush brush(CBoundingBoxAligned(CVector3D(0,0,0), CVector3D(1,1,1)));
|
|
|
|
CBrush result;
|
|
brush.Slice(plane, result);
|
|
|
|
// verify that the resulting brush consists of exactly our 8 expected, unique vertices
|
|
TS_ASSERT_EQUALS((size_t)8, result.GetVertices().size());
|
|
size_t LBF = GetUniqueVertexIndex(result, CVector3D(0, 0, 0)); // left-bottom-front <=> XYZ
|
|
size_t RBF = GetUniqueVertexIndex(result, CVector3D(1, 0, 0)); // right-bottom-front
|
|
size_t RBB = GetUniqueVertexIndex(result, CVector3D(1, 0, 1)); // right-bottom-back
|
|
size_t LBB = GetUniqueVertexIndex(result, CVector3D(0, 0, 1)); // etc.
|
|
size_t LTF = GetUniqueVertexIndex(result, CVector3D(0, 1, 0));
|
|
size_t RTF = GetUniqueVertexIndex(result, CVector3D(1, 1, 0));
|
|
size_t RTB = GetUniqueVertexIndex(result, CVector3D(1, 1, 1));
|
|
size_t LTB = GetUniqueVertexIndex(result, CVector3D(0, 1, 1));
|
|
|
|
// verify that the brush contains the six expected planes (one of which is the slicing plane)
|
|
VerifyFacePresent(result, 5, LBF, RBF, RBB, LBB, LBF); // bottom face
|
|
VerifyFacePresent(result, 5, LTF, RTF, RTB, LTB, LTF); // top face
|
|
VerifyFacePresent(result, 5, LBF, LBB, LTB, LTF, LBF); // left face
|
|
VerifyFacePresent(result, 5, RBF, RBB, RTB, RTF, RBF); // right face
|
|
VerifyFacePresent(result, 5, LBF, RBF, RTF, LTF, LBF); // front face
|
|
VerifyFacePresent(result, 5, LBB, RBB, RTB, LTB, LBB); // back face
|
|
}
|
|
|
|
void test_slice_plane_in_front_of_brush()
|
|
{
|
|
// slices the (0,0,0) to (1,1,1) cube by the plane z = -0.5, with the plane normal pointing towards the negative
|
|
// end of the Z axis (i.e. the entire cube is 'behind' the plane and should be cut away)
|
|
CPlane plane(CVector4D(0, 0, -1, -0.5f));
|
|
CBrush brush(CBoundingBoxAligned(CVector3D(0,0,0), CVector3D(1,1,1)));
|
|
|
|
CBrush result;
|
|
brush.Slice(plane, result);
|
|
|
|
TS_ASSERT_EQUALS((size_t)0, result.GetVertices().size());
|
|
|
|
std::vector<std::vector<size_t> > faces;
|
|
result.GetFaces(faces);
|
|
|
|
TS_ASSERT_EQUALS((size_t)0, faces.size());
|
|
}
|
|
|
|
private:
|
|
size_t GetUniqueVertexIndex(const CBrush& brush, const CVector3D& vertex, float eps = 1e-6f)
|
|
{
|
|
std::vector<CVector3D> vertices = brush.GetVertices();
|
|
|
|
for (size_t i = 0; i < vertices.size(); ++i)
|
|
{
|
|
const CVector3D& v = vertices[i];
|
|
if (fabs(v.X - vertex.X) < eps
|
|
&& fabs(v.Y - vertex.Y) < eps
|
|
&& fabs(v.Z - vertex.Z) < eps)
|
|
return i;
|
|
}
|
|
|
|
TS_FAIL("Vertex not found in brush");
|
|
return ~0u;
|
|
}
|
|
|
|
void VerifyFacePresent(const CBrush& brush, int count, ...)
|
|
{
|
|
std::vector<size_t> face;
|
|
|
|
va_list args;
|
|
va_start(args, count);
|
|
for (int x = 0; x < count; ++x)
|
|
face.push_back(va_arg(args, size_t));
|
|
va_end(args);
|
|
|
|
if (face.size() == 0)
|
|
return;
|
|
|
|
std::vector<std::vector<size_t> > faces;
|
|
brush.GetFaces(faces);
|
|
|
|
// the brush is free to use any starting vertex along the face, and to use any winding order, so have 'face'
|
|
// cycle through various starting values and see if any of them (or their reverse) matches one found in the brush.
|
|
|
|
for (size_t c = 0; c < face.size() - 1; ++c)
|
|
{
|
|
std::vector<std::vector<size_t> >::iterator it1 = std::find(faces.begin(), faces.end(), face);
|
|
if (it1 != faces.end())
|
|
return;
|
|
|
|
// no match, try the reverse
|
|
std::vector<size_t> faceReverse = face;
|
|
std::reverse(faceReverse.begin(), faceReverse.end());
|
|
std::vector<std::vector<size_t> >::iterator it2 = std::find(faces.begin(), faces.end(), faceReverse);
|
|
if (it2 != faces.end())
|
|
return;
|
|
|
|
// no match, cycle it
|
|
face.erase(face.begin());
|
|
face.push_back(face[0]);
|
|
}
|
|
|
|
TS_FAIL("Face not found in brush");
|
|
}
|
|
};
|