netradiant-custom/radiant/brush.cpp

/*
   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
 */

#include "brush.h"
#include "signal/signal.h"

Signal0 g_brushTextureChangedCallbacks;

void Brush_addTextureChangedCallback( const SignalHandler& handler ){
	g_brushTextureChangedCallbacks.connectLast( handler );
}

void Brush_textureChanged(){
	g_brushTextureChangedCallbacks();
}

QuantiseFunc Face::m_quantise;
EBrushType Face::m_type;
EBrushType FacePlane::m_type;
bool g_brush_texturelock_enabled = false;

EBrushType Brush::m_type;
double Brush::m_maxWorldCoord = 0;
Shader* Brush::m_state_point;
Shader* BrushClipPlane::m_state = 0;
Shader* BrushInstance::m_state_selpoint;
Counter* BrushInstance::m_counter = 0;

FaceInstanceSet g_SelectedFaceInstances;


struct SListNode
{
	SListNode* m_next;
};

class ProximalVertex
{
public:
const SListNode* m_vertices;

ProximalVertex( const SListNode* next )
	: m_vertices( next ){
}

bool operator<( const ProximalVertex& other ) const {
	if ( !( operator==( other ) ) ) {
		return m_vertices < other.m_vertices;
	}
	return false;
}
bool operator==( const ProximalVertex& other ) const {
	const SListNode* v = m_vertices;
	std::size_t DEBUG_LOOP = 0;
	do
	{
		if ( v == other.m_vertices ) {
			return true;
		}
		v = v->m_next;
		//ASSERT_MESSAGE(DEBUG_LOOP < c_brush_maxFaces, "infinite loop");
		if ( !( DEBUG_LOOP < c_brush_maxFaces ) ) {
			break;
		}
		++DEBUG_LOOP;
	}
	while ( v != m_vertices );
	return false;
}
};

typedef Array<SListNode> ProximalVertexArray;
std::size_t ProximalVertexArray_index( const ProximalVertexArray& array, const ProximalVertex& vertex ){
	return vertex.m_vertices - array.data();
}



inline bool Brush_isBounded( const Brush& brush ){
	for ( Brush::const_iterator i = brush.begin(); i != brush.end(); ++i )
	{
		if ( !( *i )->is_bounded() ) {
			return false;
		}
	}
	return true;
}

void Brush::buildBRep(){
	bool degenerate = buildWindings();

	std::size_t faces_size = 0;
	std::size_t faceVerticesCount = 0;
	for ( Faces::const_iterator i = m_faces.begin(); i != m_faces.end(); ++i )
	{
		if ( ( *i )->contributes() ) {
			++faces_size;
		}
		faceVerticesCount += ( *i )->getWinding().numpoints;
	}

	if ( degenerate || faces_size < 4 || faceVerticesCount != ( faceVerticesCount >> 1 ) << 1 ) { // sum of vertices for each face of a valid polyhedron is always even
		m_uniqueVertexPoints.resize( 0 );

		vertex_clear();
		edge_clear();

		m_edge_indices.resize( 0 );
		m_edge_faces.resize( 0 );

		m_faceCentroidPoints.resize( 0 );
		m_uniqueEdgePoints.resize( 0 );
		m_uniqueVertexPoints.resize( 0 );

		for ( Faces::iterator i = m_faces.begin(); i != m_faces.end(); ++i )
		{
			( *i )->getWinding().resize( 0 );
		}
	}
	else
	{
		{
			typedef std::vector<FaceVertexId> FaceVertices;
			FaceVertices faceVertices;
			faceVertices.reserve( faceVerticesCount );

			{
				for ( std::size_t i = 0; i != m_faces.size(); ++i )
				{
					for ( std::size_t j = 0; j < m_faces[i]->getWinding().numpoints; ++j )
					{
						faceVertices.push_back( FaceVertexId( i, j ) );
					}
				}
			}

			IndexBuffer uniqueEdgeIndices;
			typedef VertexBuffer<ProximalVertex> UniqueEdges;
			UniqueEdges uniqueEdges;

			uniqueEdgeIndices.reserve( faceVertices.size() );
			uniqueEdges.reserve( faceVertices.size() );

			{
				ProximalVertexArray edgePairs;
				edgePairs.resize( faceVertices.size() );

				{
					for ( std::size_t i = 0; i < faceVertices.size(); ++i )
					{
						edgePairs[i].m_next = edgePairs.data() + absoluteIndex( next_edge( m_faces, faceVertices[i] ) );
					}
				}

				{
					UniqueVertexBuffer<ProximalVertex> inserter( uniqueEdges );
					for ( ProximalVertexArray::iterator i = edgePairs.begin(); i != edgePairs.end(); ++i )
					{
						uniqueEdgeIndices.insert( inserter.insert( ProximalVertex( &( *i ) ) ) );
					}
				}

				{
					edge_clear();
					m_select_edges.reserve( uniqueEdges.size() );
					for ( UniqueEdges::iterator i = uniqueEdges.begin(); i != uniqueEdges.end(); ++i )
					{
						edge_push_back( faceVertices[ProximalVertexArray_index( edgePairs, *i )] );
					}
				}

				{
					m_edge_faces.resize( uniqueEdges.size() );
					for ( std::size_t i = 0; i < uniqueEdges.size(); ++i )
					{
						FaceVertexId faceVertex = faceVertices[ProximalVertexArray_index( edgePairs, uniqueEdges[i] )];
						m_edge_faces[i] = EdgeFaces( faceVertex.getFace(), m_faces[faceVertex.getFace()]->getWinding()[faceVertex.getVertex()].adjacent );
					}
				}

				{
					m_uniqueEdgePoints.resize( uniqueEdges.size() );
					for ( std::size_t i = 0; i < uniqueEdges.size(); ++i )
					{
						FaceVertexId faceVertex = faceVertices[ProximalVertexArray_index( edgePairs, uniqueEdges[i] )];

						const Winding& w = m_faces[faceVertex.getFace()]->getWinding();
						Vector3 edge = vector3_mid( w[faceVertex.getVertex()].vertex, w[Winding_next( w, faceVertex.getVertex() )].vertex );
						m_uniqueEdgePoints[i] = pointvertex_for_windingpoint( edge, colour_vertex );
					}
				}

			}


			IndexBuffer uniqueVertexIndices;
			typedef VertexBuffer<ProximalVertex> UniqueVertices;
			UniqueVertices uniqueVertices;

			uniqueVertexIndices.reserve( faceVertices.size() );
			uniqueVertices.reserve( faceVertices.size() );

			{
				ProximalVertexArray vertexRings;
				vertexRings.resize( faceVertices.size() );

				{
					for ( std::size_t i = 0; i < faceVertices.size(); ++i )
					{
						vertexRings[i].m_next = vertexRings.data() + absoluteIndex( next_vertex( m_faces, faceVertices[i] ) );
					}
				}

				{
					UniqueVertexBuffer<ProximalVertex> inserter( uniqueVertices );
					for ( ProximalVertexArray::iterator i = vertexRings.begin(); i != vertexRings.end(); ++i )
					{
						uniqueVertexIndices.insert( inserter.insert( ProximalVertex( &( *i ) ) ) );
					}
				}

				{
					vertex_clear();
					m_select_vertices.reserve( uniqueVertices.size() );
					for ( UniqueVertices::iterator i = uniqueVertices.begin(); i != uniqueVertices.end(); ++i )
					{
						vertex_push_back( faceVertices[ProximalVertexArray_index( vertexRings, ( *i ) )] );
					}
				}

				{
					m_uniqueVertexPoints.resize( uniqueVertices.size() );
					for ( std::size_t i = 0; i < uniqueVertices.size(); ++i )
					{
						FaceVertexId faceVertex = faceVertices[ProximalVertexArray_index( vertexRings, uniqueVertices[i] )];

						const Winding& winding = m_faces[faceVertex.getFace()]->getWinding();
						m_uniqueVertexPoints[i] = pointvertex_for_windingpoint( winding[faceVertex.getVertex()].vertex, colour_vertex );
					}
				}
			}

			if ( ( uniqueVertices.size() + faces_size ) - uniqueEdges.size() != 2 ) {
				globalErrorStream() << "Final B-Rep: inconsistent vertex count\n";
			}

#if BRUSH_CONNECTIVITY_DEBUG
			if ( ( uniqueVertices.size() + faces_size ) - uniqueEdges.size() != 2 ) {
				for ( Faces::iterator i = m_faces.begin(); i != m_faces.end(); ++i )
				{
					std::size_t faceIndex = std::distance( m_faces.begin(), i );

					if ( !( *i )->contributes() ) {
						globalOutputStream() << "face: " << Unsigned( faceIndex ) << " does not contribute\n";
					}

					Winding_printConnectivity( ( *i )->getWinding() );
				}
			}
#endif

			// edge-index list for wireframe rendering
			{
				m_edge_indices.resize( uniqueEdgeIndices.size() );

				for ( std::size_t i = 0, count = 0; i < m_faces.size(); ++i )
				{
					const Winding& winding = m_faces[i]->getWinding();
					for ( std::size_t j = 0; j < winding.numpoints; ++j )
					{
						const RenderIndex edge_index = uniqueEdgeIndices[count + j];

						m_edge_indices[edge_index].first = uniqueVertexIndices[count + j];
						m_edge_indices[edge_index].second = uniqueVertexIndices[count + Winding_next( winding, j )];
					}
					count += winding.numpoints;
				}
			}
		}

		{
			m_faceCentroidPoints.resize( m_faces.size() );
			for ( std::size_t i = 0; i < m_faces.size(); ++i )
			{
				m_faces[i]->construct_centroid();
				m_faceCentroidPoints[i] = pointvertex_for_windingpoint( m_faces[i]->centroid(), colour_vertex );
			}
		}
	}
}


class FaceFilterWrapper : public Filter
{
FaceFilter& m_filter;
bool m_active;
bool m_invert;
public:
FaceFilterWrapper( FaceFilter& filter, bool invert ) :
	m_filter( filter ),
	m_invert( invert ){
}
void setActive( bool active ){
	m_active = active;
}
bool active(){
	return m_active;
}
bool filter( const Face& face ){
	return m_invert ^ m_filter.filter( face );
}
};


typedef std::list<FaceFilterWrapper> FaceFilters;
FaceFilters g_faceFilters;

void add_face_filter( FaceFilter& filter, int mask, bool invert ){
	g_faceFilters.push_back( FaceFilterWrapper( filter, invert ) );
	GlobalFilterSystem().addFilter( g_faceFilters.back(), mask );
}

bool face_filtered( Face& face ){
	for ( FaceFilters::iterator i = g_faceFilters.begin(); i != g_faceFilters.end(); ++i )
	{
		if ( ( *i ).active() && ( *i ).filter( face ) ) {
			return true;
		}
	}
	return false;
}


class BrushFilterWrapper : public Filter
{
bool m_active;
bool m_invert;
BrushFilter& m_filter;
public:
BrushFilterWrapper( BrushFilter& filter, bool invert ) : m_invert( invert ), m_filter( filter ){
}
void setActive( bool active ){
	m_active = active;
}
bool active(){
	return m_active;
}
bool filter( const Brush& brush ){
	return m_invert ^ m_filter.filter( brush );
}
};


typedef std::list<BrushFilterWrapper> BrushFilters;
BrushFilters g_brushFilters;

void add_brush_filter( BrushFilter& filter, int mask, bool invert ){
	g_brushFilters.push_back( BrushFilterWrapper( filter, invert ) );
	GlobalFilterSystem().addFilter( g_brushFilters.back(), mask );
}

bool brush_filtered( Brush& brush ){
	for ( BrushFilters::iterator i = g_brushFilters.begin(); i != g_brushFilters.end(); ++i )
	{
		if ( ( *i ).active() && ( *i ).filter( brush ) ) {
			return true;
		}
	}
	return false;
}