+++ /dev/null
-/*
-Copyright (C) 1999-2006 Id Software, Inc. and contributors.
-For a list of contributors, see the accompanying CONTRIBUTORS file.
-
-This file is part of GtkRadiant.
-
-GtkRadiant 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.
-
-GtkRadiant 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 GtkRadiant; if not, write to the Free Software
-Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-*/
-
-#if !defined(INCLUDED_WINDING_H)
-#define INCLUDED_WINDING_H
-
-#include "debugging/debugging.h"
-
-#include <vector>
-
-#include "math/vector.h"
-#include "container/array.h"
-
-enum ProjectionAxis
-{
- eProjectionAxisX = 0,
- eProjectionAxisY = 1,
- eProjectionAxisZ = 2,
-};
-
-const float ProjectionAxisEpsilon = static_cast<float>(0.0001);
-
-inline bool projectionaxis_better(float axis, float other)
-{
- return fabs(axis) > fabs(other) + ProjectionAxisEpsilon;
-}
-
-/// \brief Texture axis precedence: Z > X > Y
-inline ProjectionAxis projectionaxis_for_normal(const Vector3& normal)
-{
- return (projectionaxis_better(normal[eProjectionAxisY], normal[eProjectionAxisX]))
- ? (projectionaxis_better(normal[eProjectionAxisY], normal[eProjectionAxisZ]))
- ? eProjectionAxisY
- : eProjectionAxisZ
- : (projectionaxis_better(normal[eProjectionAxisX], normal[eProjectionAxisZ]))
- ? eProjectionAxisX
- : eProjectionAxisZ;
-}
-
-
-struct indexremap_t
-{
- indexremap_t(std::size_t _x, std::size_t _y, std::size_t _z)
- : x(_x), y(_y), z(_z)
- {
- }
- std::size_t x, y, z;
-};
-
-inline indexremap_t indexremap_for_projectionaxis(const ProjectionAxis axis)
-{
- switch(axis)
- {
- case eProjectionAxisX: return indexremap_t(1, 2, 0);
- case eProjectionAxisY: return indexremap_t(2, 0, 1);
- default: return indexremap_t(0, 1, 2);
- }
-}
-
-enum PlaneClassification
-{
- ePlaneFront = 0,
- ePlaneBack = 1,
- ePlaneOn = 2,
-};
-
-#define MAX_POINTS_ON_WINDING 64
-const std::size_t c_brush_maxFaces = 1024;
-
-
-class WindingVertex
-{
-public:
- Vector3 vertex;
- Vector2 texcoord;
- Vector3 tangent;
- Vector3 bitangent;
- std::size_t adjacent;
-};
-
-
-
-struct Winding
-{
- typedef Array<WindingVertex> container_type;
-
- std::size_t numpoints;
- container_type points;
-
- typedef container_type::iterator iterator;
- typedef container_type::const_iterator const_iterator;
-
- Winding() : numpoints(0)
- {
- }
- Winding(std::size_t size) : numpoints(0), points(size)
- {
- }
- void resize(std::size_t size)
- {
- points.resize(size);
- numpoints = 0;
- }
-
- iterator begin()
- {
- return points.begin();
- }
- const_iterator begin() const
- {
- return points.begin();
- }
- iterator end()
- {
- return points.begin() + numpoints;
- }
- const_iterator end() const
- {
- return points.begin() + numpoints;
- }
-
- WindingVertex& operator[](std::size_t index)
- {
- ASSERT_MESSAGE(index < points.size(), "winding: index out of bounds");
- return points[index];
- }
- const WindingVertex& operator[](std::size_t index) const
- {
- ASSERT_MESSAGE(index < points.size(), "winding: index out of bounds");
- return points[index];
- }
-
- void push_back(const WindingVertex& point)
- {
- points[numpoints] = point;
- ++numpoints;
- }
- void erase(iterator point)
- {
- for(iterator i = point + 1; i != end(); point = i, ++i)
- {
- *point = *i;
- }
- --numpoints;
- }
-};
-
-typedef BasicVector3<double> DoubleVector3;
-
-class DoubleLine
-{
-public:
- DoubleVector3 origin;
- DoubleVector3 direction;
-};
-
-class FixedWindingVertex
-{
-public:
- DoubleVector3 vertex;
- DoubleLine edge;
- std::size_t adjacent;
-
- FixedWindingVertex(const DoubleVector3& vertex_, const DoubleLine& edge_, std::size_t adjacent_)
- : vertex(vertex_), edge(edge_), adjacent(adjacent_)
- {
- }
-};
-
-struct FixedWinding
-{
- typedef std::vector<FixedWindingVertex> Points;
- Points points;
-
- FixedWinding()
- {
- points.reserve(MAX_POINTS_ON_WINDING);
- }
-
- FixedWindingVertex& front()
- {
- return points.front();
- }
- const FixedWindingVertex& front() const
- {
- return points.front();
- }
- FixedWindingVertex& back()
- {
- return points.back();
- }
- const FixedWindingVertex& back() const
- {
- return points.back();
- }
-
- void clear()
- {
- points.clear();
- }
-
- void push_back(const FixedWindingVertex& point)
- {
- points.push_back(point);
- }
- std::size_t size() const
- {
- return points.size();
- }
-
- FixedWindingVertex& operator[](std::size_t index)
- {
- //ASSERT_MESSAGE(index < MAX_POINTS_ON_WINDING, "winding: index out of bounds");
- return points[index];
- }
- const FixedWindingVertex& operator[](std::size_t index) const
- {
- //ASSERT_MESSAGE(index < MAX_POINTS_ON_WINDING, "winding: index out of bounds");
- return points[index];
- }
-
-};
-
-
-inline void Winding_forFixedWinding(Winding& winding, const FixedWinding& fixed)
-{
- winding.resize(fixed.size());
- winding.numpoints = fixed.size();
- for(std::size_t i = 0; i < fixed.size(); ++i)
- {
- winding[i].vertex[0] = static_cast<float>(fixed[i].vertex[0]);
- winding[i].vertex[1] = static_cast<float>(fixed[i].vertex[1]);
- winding[i].vertex[2] = static_cast<float>(fixed[i].vertex[2]);
- winding[i].adjacent = fixed[i].adjacent;
- }
-}
-
-inline std::size_t Winding_wrap(const Winding& winding, std::size_t i)
-{
- ASSERT_MESSAGE(winding.numpoints != 0, "Winding_wrap: empty winding");
- return i % winding.numpoints;
-}
-
-inline std::size_t Winding_next(const Winding& winding, std::size_t i)
-{
- return Winding_wrap(winding, ++i);
-}
-
-
-class Plane3;
-
-void Winding_createInfinite(FixedWinding& w, const Plane3& plane, double infinity);
-
-const double ON_EPSILON = 1.0 / (1 << 8);
-
-/// \brief Returns true if edge (\p x, \p y) is smaller than the epsilon used to classify winding points against a plane.
-inline bool Edge_isDegenerate(const Vector3& x, const Vector3& y)
-{
- return vector3_length_squared(y - x) < (ON_EPSILON * ON_EPSILON);
-}
-
-void Winding_Clip(const FixedWinding& winding, const Plane3& plane, const Plane3& clipPlane, std::size_t adjacent, FixedWinding& clipped);
-
-struct brushsplit_t
-{
- brushsplit_t()
- {
- counts[0] = 0;
- counts[1] = 0;
- counts[2] = 0;
- }
- brushsplit_t& operator+=(const brushsplit_t& other)
- {
- counts[0] += other.counts[0];
- counts[1] += other.counts[1];
- counts[2] += other.counts[2];
- return *this;
- }
- std::size_t counts[3];
-};
-
-brushsplit_t Winding_ClassifyPlane(const Winding& w, const Plane3& plane);
-
-bool Winding_PlanesConcave(const Winding& w1, const Winding& w2, const Plane3& plane1, const Plane3& plane2);
-bool Winding_TestPlane(const Winding& w, const Plane3& plane, bool flipped);
-
-std::size_t Winding_FindAdjacent(const Winding& w, std::size_t face);
-
-std::size_t Winding_Opposite(const Winding& w, const std::size_t index, const std::size_t other);
-std::size_t Winding_Opposite(const Winding& w, std::size_t index);
-
-void Winding_Centroid(const Winding& w, const Plane3& plane, Vector3& centroid);
-
-
-inline void Winding_printConnectivity(Winding& winding)
-{
- for(Winding::iterator i = winding.begin(); i != winding.end(); ++i)
- {
- std::size_t vertexIndex = std::distance(winding.begin(), i);
- globalOutputStream() << "vertex: " << Unsigned(vertexIndex) << " adjacent: " << Unsigned((*i).adjacent) << "\n";
- }
-}
-
-#endif
projects / voretournament / voretournament.git / blobdiff