/*
-Copyright (C) 1999-2006 Id Software, Inc. and contributors.
-For a list of contributors, see the accompanying CONTRIBUTORS file.
+ 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.
+ 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 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.
+ 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
-*/
+ 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)
+#if !defined( INCLUDED_WINDING_H )
#define INCLUDED_WINDING_H
#include "debugging/debugging.h"
enum ProjectionAxis
{
- eProjectionAxisX = 0,
- eProjectionAxisY = 1,
- eProjectionAxisZ = 2,
+ eProjectionAxisX = 0,
+ eProjectionAxisY = 1,
+ eProjectionAxisZ = 2,
};
-const float ProjectionAxisEpsilon = static_cast<float>(0.0001);
+const float ProjectionAxisEpsilon = static_cast<float>( 0.0001 );
-inline bool projectionaxis_better(float axis, float other)
-{
- return fabs(axis) > fabs(other) + ProjectionAxisEpsilon;
+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;
+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;
+ 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);
- }
+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,
+ ePlaneFront = 0,
+ ePlaneBack = 1,
+ ePlaneOn = 2,
};
#define MAX_POINTS_ON_WINDING 64
class WindingVertex
{
public:
- Vector3 vertex;
- Vector2 texcoord;
- Vector3 tangent;
- Vector3 bitangent;
- std::size_t adjacent;
+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 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;
+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_)
- {
- }
+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];
- }
+ 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 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_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);
+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);
+void Winding_createInfinite( FixedWinding& w, const Plane3& plane, double infinity );
-const double ON_EPSILON = 1.0 / (1 << 8);
+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);
+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);
+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(){
+ 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);
+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);
+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_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);
+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);
+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";
- }
+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 / xonotic / netradiant.git / blobdiff