ViewMapBuilder.h

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once

 
#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"
 
#include "MEM_guardedalloc.h"
 
namespace Freestyle {
 
using namespace Geometry;
 
class 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;
 
 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;
 
  inline ViewMapBuilder()
  {
    _pProgressBar = nullptr;
    _pRenderMonitor = nullptr;
    _Grid = nullptr;
    _currentId = 1;
    _currentFId = 0;
    _currentSVertexId = 0;
    _pViewEdgeBuilder = new ViewEdgeXBuilder;
    _EnableQI = true;
  }
 
  inline ~ViewMapBuilder()
  {
    if (_pViewEdgeBuilder) {
      delete _pViewEdgeBuilder;
      _pViewEdgeBuilder = nullptr;
    }
  }
 
  /* Build Grid for ray casting */
  void BuildGrid(WingedEdge &we, const BBox<Vec3r> &bbox, uint sceneNumFaces);

  void computeInitialViewEdges(WingedEdge &);

  void computeCusps(ViewMap *ioViewMap);

  void DetectCusps(ViewEdge *ioEdge);

  inline void setViewpoint(const Vec3r &ivp)
  {
    _viewpoint = ivp;
    SilhouetteGeomEngine::setViewpoint(ivp);
  }

  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);
  }

  ViewMap *BuildViewMap(WingedEdge &we,
                        visibility_algo iAlgo,
                        real epsilon,
                        const BBox<Vec3r> &bbox,
                        uint sceneNumFaces);
 
  void CullViewEdges(ViewMap *ioViewMap,
                     real viewProscenium[4],
                     real occluderProscenium[4],
                     bool extensiveFEdgeSearch = true);

  void ComputeIntersections(ViewMap *ioViewMap,
                            intersection_algo iAlgo = sweep_line,
                            real epsilon = 1.0e-06);

  void ComputeEdgesVisibility(ViewMap *ioViewMap,
                              WingedEdge &we,
                              const BBox<Vec3r> &bbox,
                              uint sceneNumFaces,
                              visibility_algo iAlgo = ray_casting,
                              real epsilon = 1.0e-6);
 
  void setGrid(Grid *iGrid)
  {
    _Grid = iGrid;
  }


  inline void setProgressBar(ProgressBar *iProgressBar)
  {
    _pProgressBar = iProgressBar;
  }
 
  inline void setRenderMonitor(RenderMonitor *iRenderMonitor)
  {
    _pRenderMonitor = iRenderMonitor;
  }
 
  inline void setEnableQI(bool iBool)
  {
    _EnableQI = iBool;
  }
 
 protected:
  void ComputeSweepLineIntersections(ViewMap *ioViewMap, real epsilon = 1.0e-6);

  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);
 
  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);

  int ComputeRayCastingVisibility(FEdge *fe,
                                  Grid *iGrid,
                                  real epsilon,
                                  set<ViewShape *> &oOccluders,
                                  Polygon3r **oaPolygon,
                                  uint timestamp);
  // FIXME
  void FindOccludee(FEdge *fe, Grid *iGrid, real epsilon, Polygon3r **oaPolygon, uint timestamp);
  void FindOccludee(FEdge *fe,
                    Grid *iGrid,
                    real epsilon,
                    Polygon3r **oaPolygon,
                    uint timestamp,
                    Vec3r &u,
                    Vec3r &A,
                    Vec3r &origin,
                    Vec3r &edgeDir,
                    vector<WVertex *> &faceVertices);
 
  MEM_CXX_CLASS_ALLOC_FUNCS("Freestyle:ViewMapBuilder")
};
 
} /* namespace Freestyle */