Canvas.h

Go to the documentation of this file.

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

 
#include <cstring>
#include <deque>
#include <map>
#include <vector>
 
#include "StrokeLayer.h"
 
#include "../geometry/BBox.h"
#include "../geometry/Geom.h"
 
#include "../system/FreestyleConfig.h"
 
#include "MEM_guardedalloc.h"
 
namespace Freestyle {
 
using namespace Geometry;
 
struct ltstr {
  bool operator()(const char *s1, const char *s2) const
  {
    return strcmp(s1, s2) < 0;
  }
};
 
class InformationMap;
class StrokeRenderer;
class ViewMap;
class ViewEdge;
class FEdge;
class RGBImage;
class GrayImage;
class QImage;
class ImagePyramid;
class SteerableViewMap;
class StyleModule;

class Canvas {
 public:
  static Canvas *getInstance()
  {
    return _pInstance;
  }
 
  typedef std::map<const char *, ImagePyramid *, ltstr> mapsMap;
  static const int NB_STEERABLE_VIEWMAP = 5;
 
 protected:
  static Canvas *_pInstance;
  std::deque<StrokeLayer *> _Layers;
  std::deque<StyleModule *> _StyleModules;
  FEdge *_SelectedFEdge;
 
  StrokeRenderer *_Renderer;
  StyleModule *_current_sm;
  mapsMap _maps;
  static const char *_MapsPath;
  SteerableViewMap *_steerableViewMap;
  bool _basic;
  int stroke_count;
 
 public:
  /* Builds the Canvas */
  Canvas();
  /* Copy constructor */
  Canvas(const Canvas &iBrother);
  /* Destructor */
  virtual ~Canvas();
 
  /* operations that need to be done before a draw */
  virtual void preDraw();
 
  /* Draw the canvas using the current shader */
  virtual void Draw();
 
  /* operations that need to be done after a draw */
  virtual void postDraw();
 
  /* Renders the created strokes */
  virtual void Render(const StrokeRenderer *iRenderer);
  /* Basic Renders the created strokes */
  virtual void RenderBasic(const StrokeRenderer *iRenderer);
  /* Renders a stroke */
  virtual void RenderStroke(Stroke *iStroke) = 0;
 
  /* init the canvas */
  virtual void init() = 0;
 
  /* Clears the Canvas (shaders stack, layers stack...) */
  void Clear();
 
  /* Erases the layers */
  virtual void Erase();
 
  /* Reads a pixel area from the canvas */
  virtual void readColorPixels(int x, int y, int w, int h, RGBImage &oImage) const = 0;
  /* Reads a depth pixel area from the canvas */
  virtual void readDepthPixels(int x, int y, int w, int h, GrayImage &oImage) const = 0;
 
  /* update the canvas (display) */
  virtual void update() = 0;
 
  /* checks whether the canvas is empty or not */
  bool isEmpty() const
  {
    return (_Layers.empty());
  }
 
  /* Maps management */
  void loadMap(const char *iFileName,
               const char *iMapName,
               uint iNbLevels = 4,
               float iSigma = 1.0f);

  float readMapPixel(const char *iMapName, int level, int x, int y);

  void loadSteerableViewMap(SteerableViewMap *iSVM)
  {
    _steerableViewMap = iSVM;
  }

  SteerableViewMap *getSteerableViewMap()
  {
    return _steerableViewMap;
  }

  inline const FEdge *selectedFEdge() const
  {
    return _SelectedFEdge;
  }
 
  inline FEdge *selectedFEdge()
  {
    return _SelectedFEdge;
  }
 
  virtual int width() const = 0;
  virtual int height() const = 0;
  virtual BBox<Vec2i> border() const = 0;
  virtual BBox<Vec3r> scene3DBBox() const = 0;
 
  inline const StrokeRenderer *renderer() const
  {
    return _Renderer;
  }
 
  inline StyleModule *getCurrentStyleModule()
  {
    return _current_sm;
  }
 
  virtual bool getRecordFlag() const
  {
    return false;
  }
 
  inline int getStrokeCount() const
  {
    return stroke_count;
  }

  inline void setSelectedFEdge(FEdge *iFEdge)
  {
    _SelectedFEdge = iFEdge;
  }

  void PushBackStyleModule(StyleModule *iStyleModule);
  void InsertStyleModule(uint index, StyleModule *iStyleModule);
  void RemoveStyleModule(uint index);
  void SwapStyleModules(uint i1, uint i2);
  void ReplaceStyleModule(uint index, StyleModule *iStyleModule);
  void setVisible(uint index, bool iVisible);
 
#if 0
  inline void setDensityMap(InformationMap<RGBImage> *iMap)
  {
    _DensityMap = iMap;
  }
#endif
 
  inline void AddLayer(StrokeLayer *iLayer)
  {
    _Layers.push_back(iLayer);
  }
 
  void resetModified(bool iMod = false);
  void causalStyleModules(std::vector<uint> &vec, uint index = 0);
  void setModified(uint index, bool iMod);
 
  MEM_CXX_CLASS_ALLOC_FUNCS("Freestyle:Canvas")
};
 
} /* namespace Freestyle */