gtkradiant/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;
}