Yet another big style clean-up patch by Bastien Montagne, thanks a lot!

Now the code style is acceptable for the merge now, according to Bastien.
Thanks again Bastien for having this done! :)

1 files changed, 240 insertions, 231 deletions

diff --git a/source/blender/freestyle/intern/view_map/ViewMapBuilder.h b/source/blender/freestyle/intern/view_map/ViewMapBuilder.h
index a41df92062e..2d5d24a0ffe 100644
--- a/source/blender/freestyle/intern/view_map/ViewMapBuilder.h
+++ b/source/blender/freestyle/intern/view_map/ViewMapBuilder.h
@@ -1,248 +1,257 @@
-//
-//  Filename         : ViewMapBuilder.h
-//  Author(s)        : Stephane Grabli
-//  Purpose          : Class to build silhouette edges from a
-//                     Winged-Edge structure
-//  Date of creation : 25/03/2002
-//
-///////////////////////////////////////////////////////////////////////////////
-
-
-//
-//  Copyright (C) : Please refer to the COPYRIGHT file distributed 
-//   with this source distribution. 
-//
-//  This program 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.
-//
-//  This program 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 this program; if not, write to the Free Software
-//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-//
-///////////////////////////////////////////////////////////////////////////////
-
-#ifndef  VIEWMAPBUILDER_H
-# define VIEWMAPBUILDER_H
-
-# include "Silhouette.h"
-# include <vector>
-# include "../system/FreestyleConfig.h"
-# include "../geometry/Geom.h"
-# include "../scene_graph/NodeGroup.h"
-# include "../winged_edge/WXEdge.h"
-# include "../geometry/GeomUtils.h"
-# include "../geometry/Grid.h"
-# include "../system/ProgressBar.h"
-# include "../system/RenderMonitor.h"
-# include "../geometry/SweepLine.h"
-# include "ViewMap.h"
-# include "SilhouetteGeomEngine.h"
-# include "../scene_graph/TriangleRep.h"
-# include "../winged_edge/WEdge.h"
-# include "ViewEdgeXBuilder.h"
-# include "../system/TimeUtils.h"
-# include "GridDensityProvider.h"
+/*
+ * ***** BEGIN GPL LICENSE BLOCK *****
+ *
+ * This program 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.
+ *
+ * This program 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 this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ *
+ * The Original Code is Copyright (C) 2010 Blender Foundation.
+ * All rights reserved.
+ *
+ * The Original Code is: all of this file.
+ *
+ * Contributor(s): none yet.
+ *
+ * ***** END GPL LICENSE BLOCK *****
+ */
+
+#ifndef __FREESTYLE_VIEW_MAP_BUILDER_H__
+#define __FREESTYLE_VIEW_MAP_BUILDER_H__
+
+/** \file blender/freestyle/intern/view_map/ViewMapBuilder.h
+ *  \ingroup freestyle
+ *  \brief Class to build silhouette edges from a Winged-Edge structure
+ *  \author Stephane Grabli
+ *  \date 25/03/2002
+ */
+
+#include <vector>
+
+#include "GridDensityProvider.h"
+#include "Silhouette.h"
+#include "SilhouetteGeomEngine.h"
+#include "ViewEdgeXBuilder.h"
+#include "ViewMap.h"
+
+#include "../geometry/Geom.h"
+#include "../geometry/GeomUtils.h"
+#include "../geometry/Grid.h"
+#include "../geometry/SweepLine.h"
+
+#include "../scene_graph/NodeGroup.h"
+#include "../scene_graph/TriangleRep.h"
+
+#include "../system/FreestyleConfig.h"
+#include "../system/ProgressBar.h"
+#include "../system/RenderMonitor.h"
+#include "../system/TimeUtils.h"
+
+#include "../winged_edge/WEdge.h"
+#include "../winged_edge/WXEdge.h"
 
 using namespace Geometry;
 
 class LIB_VIEW_MAP_EXPORT ViewMapBuilder
 {
 private:
+	ViewMap *_ViewMap; // result
+	//SilhouetteGeomEngine _GeomEngine;
+	ProgressBar *_pProgressBar;
+	RenderMonitor *_pRenderMonitor;
+	Vec3r _viewpoint;
+	bool _orthographicProjection;
+	Grid *_Grid;
+	ViewEdgeXBuilder *_pViewEdgeBuilder;
+	bool _EnableQI;
+	double _epsilon;
+
+	// tmp values:
+	int _currentId;
+	int _currentFId;
+	int _currentSVertexId;
 
-  ViewMap * _ViewMap; // result
-  //SilhouetteGeomEngine _GeomEngine;
-  ProgressBar *_pProgressBar;
-  RenderMonitor *_pRenderMonitor;
-  Vec3r _viewpoint;
-  bool _orthographicProjection;
-  Grid* _Grid;
-  ViewEdgeXBuilder *_pViewEdgeBuilder;
-  bool _EnableQI;
-  double _epsilon;
+public:
+	typedef enum {
+		sweep_line,
+	} intersection_algo;
 
+	typedef enum {
+		ray_casting,
+		ray_casting_fast,
+		ray_casting_very_fast,
+		ray_casting_culled_adaptive_traditional,
+		ray_casting_adaptive_traditional,
+		ray_casting_culled_adaptive_cumulative,
+		ray_casting_adaptive_cumulative,
+	} visibility_algo;
 
-  // tmp values:
-  int _currentId;
-  int _currentFId;
-  int _currentSVertexId;
-  
+	inline ViewMapBuilder()
+	{
+		_pProgressBar = NULL;
+		_pRenderMonitor = NULL;
+		_Grid = NULL;
+		_currentId = 1;
+		_currentFId = 0;
+		_currentSVertexId = 0;
+		_pViewEdgeBuilder = new ViewEdgeXBuilder;
+		_EnableQI = true;
+	}
 
-public:
+	inline ~ViewMapBuilder()
+	{
+		if (_pViewEdgeBuilder) {
+			delete _pViewEdgeBuilder;
+			_pViewEdgeBuilder = NULL;
+		}
+	}
+
+	/* Build Grid for ray casting */
+	/*! Build non-culled Grid in camera space for ray casting */
+	void BuildGrid(WingedEdge& we, const BBox<Vec3r>& bbox, unsigned int sceneNumFaces);
+
+	/*! Compute Shapes from a WingedEdge containing a list of WShapes */
+	void computeInitialViewEdges(WingedEdge&);
+
+	/*! Compute Cusps */
+	void computeCusps(ViewMap *ioViewMap);
 
-  typedef enum {
-    sweep_line
-  } intersection_algo;
-
-  typedef enum {
-    ray_casting,
-    ray_casting_fast,
-    ray_casting_very_fast,
-    ray_casting_culled_adaptive_traditional,
-    ray_casting_adaptive_traditional,
-    ray_casting_culled_adaptive_cumulative,
-    ray_casting_adaptive_cumulative
-  } visibility_algo;
-
-  inline ViewMapBuilder()
-  {
-    _pProgressBar = 0;
-    _pRenderMonitor = 0;
-    _Grid = 0;
-    _currentId = 1;
-    _currentFId = 0;
-    _currentSVertexId = 0;
-    _pViewEdgeBuilder = new ViewEdgeXBuilder;
-    _EnableQI = true;
-  }
-
-  inline ~ViewMapBuilder() 
-  {
-    if(_pViewEdgeBuilder){
-      delete _pViewEdgeBuilder;
-      _pViewEdgeBuilder = 0;
-    }
-  }
-
-  /* Build Grid for ray casting */
-  /*! Build non-culled Grid in camera space for ray casting */
-  void BuildGrid(WingedEdge& we, const BBox<Vec3r>& bbox, unsigned int sceneNumFaces);
-
-  /*! Compute Shapes from a WingedEdge containing a list of WShapes */
-  void computeInitialViewEdges(WingedEdge&);
-
-  /*! Compute Cusps */
-  void computeCusps(ViewMap *ioViewMap);
-  /*! Detects cusps (for a single ViewEdge) among SVertices and builds a ViewVertex on top of 
-   *  each cusp SVertex
-   *  We use a hysteresis approach to avoid noise.
-   */
-  void DetectCusps(ViewEdge *ioEdge);
-
-
-  /*! Sets the current viewpoint */
-  inline void setViewpoint(const Vec3r& ivp) {_viewpoint = ivp; SilhouetteGeomEngine::setViewpoint(ivp);}
-
-  /*! Sets the current transformation
-   *    iModelViewMatrix
-   *      The 4x4 model view matrix, in column major order (openGL like).
-   *    iProjection matrix
-   *      The 4x4 projection matrix, in column major order (openGL like).
-   *    iViewport
-   *      The viewport. 4 real array: origin.x, origin.y, width, length
-   */
-  inline void setTransform(const real iModelViewMatrix[4][4],
-			   const real iProjectionMatrix[4][4],
-			   const int iViewport[4],
-			   real iFocalLength,
-			   real iAspect,
-			   real iFovy) {
-	_orthographicProjection = (iProjectionMatrix[3][3] != 0.0);
-    SilhouetteGeomEngine::setTransform(iModelViewMatrix, iProjectionMatrix, iViewport, iFocalLength);
-  }
-  
-  inline void setFrustum(real iZnear, real iZfar) {
-    SilhouetteGeomEngine::setFrustum(iZnear, iZfar);
-  }
-
-  /*! Builds the scene view map
-   *  returns the list the view map
-   *  it is up to the caller to delete this ViewMap
-   *    iWRoot
-   *      The root group node containing the WEdge structured scene 
-   */
-
-  ViewMap* BuildViewMap(WingedEdge& we, visibility_algo iAlgo, real epsilon, 
-      const BBox<Vec3r>& bbox, unsigned int sceneNumFaces);
-  void CullViewEdges(ViewMap *ioViewMap, real viewProscenium[4], real occluderProscenium[4], bool extensiveFEdgeSearch = true);
-  /*! computes the intersection between all 2D
-   *  feature edges of the scene.
-   *    ioViewMap
-   *      The view map. It is modified by the method.
-   *      The list of all features edges of the scene.
-   *      Each time an intersection is found, the 2 intersecting
-   *      edges are splitted (creating 2 new vertices)
-   *      At the end, this list is updated with the adding
-   *      of all new created edges (resulting from splitting).
-   *    iAlgo
-   *      The algo to use for computing the intersections
-   */
-  void ComputeIntersections(ViewMap *ioViewMap, intersection_algo iAlgo = sweep_line, real epsilon=1e-06);
-
-  /*! Computes the 2D scene silhouette edges visibility
-   *    iGrid
-   *      For the Ray Casting algorithm. 
-   */
-  void ComputeEdgesVisibility(ViewMap *ioViewMap, WingedEdge& we, const BBox<Vec3r>& bbox, unsigned int sceneNumFaces, 
-      visibility_algo iAlgo= ray_casting, real epsilon=1e-6);
-
-  void setGrid(Grid *iGrid) {_Grid = iGrid;}
-  
-  /*! accessors */
- 
-  /*! Modifiers */
-  inline void setProgressBar(ProgressBar *iProgressBar) {_pProgressBar = iProgressBar;}
-  inline void setRenderMonitor(RenderMonitor *iRenderMonitor) {_pRenderMonitor = iRenderMonitor;}
-  inline void setEnableQI(bool iBool) {_EnableQI = iBool;}
+	/*! Detects cusps (for a single ViewEdge) among SVertices and builds a ViewVertex on top of each cusp SVertex
+	 *  We use a hysteresis approach to avoid noise.
+	 */
+	void DetectCusps(ViewEdge *ioEdge);
+
+	/*! Sets the current viewpoint */
+	inline void setViewpoint(const Vec3r& ivp)
+	{
+		_viewpoint = ivp;
+		SilhouetteGeomEngine::setViewpoint(ivp);
+	}
+
+	/*! Sets the current transformation
+	 *    iModelViewMatrix
+	 *      The 4x4 model view matrix, in column major order (openGL like).
+	 *    iProjection matrix
+	 *      The 4x4 projection matrix, in column major order (openGL like).
+	 *    iViewport
+	 *      The viewport. 4 real array: origin.x, origin.y, width, length
+	 */
+	inline void setTransform(const real iModelViewMatrix[4][4], const real iProjectionMatrix[4][4],
+	                         const int iViewport[4], real iFocalLength, real iAspect, real iFovy)
+	{
+		_orthographicProjection = (iProjectionMatrix[3][3] != 0.0);
+		SilhouetteGeomEngine::setTransform(iModelViewMatrix, iProjectionMatrix, iViewport, iFocalLength);
+	}
+
+	inline void setFrustum(real iZnear, real iZfar)
+	{
+		SilhouetteGeomEngine::setFrustum(iZnear, iZfar);
+	}
+
+	/*! Builds the scene view map returns the list the view map
+	 *  it is up to the caller to delete this ViewMap
+	 *    iWRoot
+	 *      The root group node containing the WEdge structured scene 
+	 */
+	ViewMap *BuildViewMap(WingedEdge& we, visibility_algo iAlgo, real epsilon, const BBox<Vec3r>& bbox,
+	                      unsigned int sceneNumFaces);
+
+	void CullViewEdges(ViewMap *ioViewMap, real viewProscenium[4], real occluderProscenium[4],
+	                   bool extensiveFEdgeSearch = true);
+
+	/*! computes the intersection between all 2D feature edges of the scene.
+	 *    ioViewMap
+	 *      The view map. It is modified by the method.
+	 *      The list of all features edges of the scene.
+	 *      Each time an intersection is found, the 2 intersecting edges are splitted (creating 2 new vertices)
+	 *      At the end, this list is updated with the adding of all new created edges (resulting from splitting).
+	 *    iAlgo
+	 *      The algo to use for computing the intersections
+	 */
+	void ComputeIntersections(ViewMap *ioViewMap, intersection_algo iAlgo = sweep_line, real epsilon = 1.0e-06);
+
+	/*! Computes the 2D scene silhouette edges visibility
+	 *    iGrid
+	 *      For the Ray Casting algorithm. 
+	 */
+	void ComputeEdgesVisibility(ViewMap *ioViewMap, WingedEdge& we, const BBox<Vec3r>& bbox, unsigned int sceneNumFaces,
+	                            visibility_algo iAlgo = ray_casting, real epsilon = 1.0e-6);
+
+	void setGrid(Grid *iGrid)
+	{
+		_Grid = iGrid;
+	}
+
+	/*! accessors */
+
+	/*! Modifiers */
+	inline void setProgressBar(ProgressBar *iProgressBar)
+	{
+		_pProgressBar = iProgressBar;
+	}
+
+	inline void setRenderMonitor(RenderMonitor *iRenderMonitor)
+	{
+		_pRenderMonitor = iRenderMonitor;
+	}
+
+	inline void setEnableQI(bool iBool)
+	{
+		_EnableQI = iBool;
+	}
 
 protected:
+	/*! Computes intersections on all edges of the scene using a sweep line algorithm */
+	void ComputeSweepLineIntersections(ViewMap *ioViewMap, real epsilon = 1.0e-6);
+
+	/*! Computes the 2D scene silhouette edges visibility using a ray casting. On each edge, a ray is cast
+	 *  to check its quantitative invisibility. The list of occluders are each time stored in the tested edge.
+	 *    ioViewMap
+	 *      The view map.
+	 *      The 2D scene silhouette edges as FEdges.
+	 *      These edges have already been splitted at their intersections points.
+	 *      Thus, these edges do not intersect anymore.
+	 *      The visibility corresponding to each edge of ioScene is set is this edge.
+	 */
+	void ComputeRayCastingVisibility(ViewMap *ioViewMap, real epsilon = 1.0e-6);
+	void ComputeFastRayCastingVisibility(ViewMap *ioViewMap, real epsilon = 1.0e-6);
+	void ComputeVeryFastRayCastingVisibility(ViewMap *ioViewMap, real epsilon = 1.0e-6);
 
-  /*! Computes intersections on all edges of the scene using a sweep line 
-   *  algorithm*/
-  void ComputeSweepLineIntersections(ViewMap *ioViewMap, real epsilon = 1e-6);
-
-  /*! Computes the 2D scene silhouette edges visibility
-   *  using a ray casting. On each edge, a ray is cast
-   *  to check its quantitative invisibility. The list
-   *  of occluders are each time stored in the tested edge.
-   *    ioViewMap
-   *      The view map.
-   *      The 2D scene silhouette edges as FEdges.
-   *      These edges have already been splitted at their intersections points.
-   *      Thus, these edges do not intersect anymore.
-   *      The visibility corresponding to each edge of ioScene is set is this
-   *      edge.
-   */
-  void ComputeRayCastingVisibility(ViewMap *ioViewMap, real epsilon=1e-6);
-  void ComputeFastRayCastingVisibility(ViewMap *ioViewMap, real epsilon=1e-6);
-  void ComputeVeryFastRayCastingVisibility(ViewMap *ioViewMap, real epsilon=1e-6);
-
-void ComputeCumulativeVisibility(ViewMap *ioViewMap, WingedEdge& we, 
-	const BBox<Vec3r>& bbox, real epsilon, bool cull, GridDensityProviderFactory& factory);
-void ComputeDetailedVisibility(ViewMap *ioViewMap, WingedEdge& we, 
-	const BBox<Vec3r>& bbox, real epsilon, bool cull, GridDensityProviderFactory& factory);
-
-  /*! Compute the visibility for the FEdge fe.
-   *  The occluders are added to fe occluders list.
-   *    fe
-   *      The FEdge
-   *    iGrid
-   *      The grid used to compute the ray casting visibility
-   *    epsilon
-   *      The epsilon used for computation
-   *    oShapeId
-   *      fe is the border (in 2D) between 2 2D spaces.
-   *      if fe is a silhouette,
-   *      One of these 2D spaces is occupied by the shape
-   *      to which fe belongs (on its left) and the other one is either occupied 
-   *      by another shape or empty or occupied by the same shape.
-   *      We use this ray csating operation to determine which shape 
-   *      lies on fe's right.
-   *      The result is the shape id stored in oShapeId
-   */
-  int ComputeRayCastingVisibility(FEdge *fe, Grid* iGrid, real epsilon, set<ViewShape*>& oOccluders,
-                                  Polygon3r** oaPolygon, unsigned timestamp);
-  // FIXME
-  void FindOccludee(FEdge *fe, Grid* iGrid, real epsilon, Polygon3r** oaPolygon, unsigned timestamp);
-  void FindOccludee(FEdge *fe, Grid* iGrid, real epsilon, Polygon3r** oaPolygon, unsigned timestamp,
-                    Vec3r& u, Vec3r& A, Vec3r& origin, Vec3r& edge, vector<WVertex*>& faceVertices);
+	void ComputeCumulativeVisibility(ViewMap *ioViewMap, WingedEdge& we, const BBox<Vec3r>& bbox, real epsilon,
+	                                 bool cull, GridDensityProviderFactory& factory);
+	void ComputeDetailedVisibility(ViewMap *ioViewMap, WingedEdge& we, const BBox<Vec3r>& bbox, real epsilon,
+	                               bool cull, GridDensityProviderFactory& factory);
 
+	/*! Compute the visibility for the FEdge fe.
+	 *  The occluders are added to fe occluders list.
+	 *    fe
+	 *      The FEdge
+	 *    iGrid
+	 *      The grid used to compute the ray casting visibility
+	 *    epsilon
+	 *      The epsilon used for computation
+	 *    oShapeId
+	 *      fe is the border (in 2D) between 2 2D spaces.
+	 *      if fe is a silhouette, One of these 2D spaces is occupied by the shape to which fe belongs (on its left)
+	 *      and the other one is either occupied by another shape or empty or occupied by the same shape.
+	 *      We use this ray csating operation to determine which shape lies on fe's right.
+	 *      The result is the shape id stored in oShapeId
+	 */
+	int ComputeRayCastingVisibility(FEdge *fe, Grid *iGrid, real epsilon, set<ViewShape*>& oOccluders,
+	                                Polygon3r **oaPolygon, unsigned timestamp);
+	// FIXME
+	void FindOccludee(FEdge *fe, Grid *iGrid, real epsilon, Polygon3r **oaPolygon, unsigned timestamp);
+	void FindOccludee(FEdge *fe, Grid *iGrid, real epsilon, Polygon3r **oaPolygon, unsigned timestamp,
+	                  Vec3r& u, Vec3r& A, Vec3r& origin, Vec3r& edge, vector<WVertex*>& faceVertices);
 };
 
-#endif // VIEWMAPBUILDER_H
+#endif // __FREESTYLE_VIEW_MAP_BUILDER_H__