Interface0D.h

Go to the documentation of this file.

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

 
#include <iostream>
#include <string>
 
#include "../geometry/Geom.h"
 
#include "../system/Id.h"
#include "../system/Iterator.h"
#include "../system/Precision.h"
 
#include "../winged_edge/Nature.h"
 
#include "MEM_guardedalloc.h"
 
using namespace std;
 
namespace Freestyle {
 
//
// Interface0D
//
 
class FEdge;
class SVertex;
class ViewVertex;
class NonTVertex;
class TVertex;

class Interface0D {
 public:
  Interface0D() {}

  virtual ~Interface0D() {};

  virtual string getExactTypeName() const
  {
    return "Interface0D";
  }
 
  // Data access methods

  virtual real getX() const;

  virtual real getY() const;

  virtual real getZ() const;

  virtual Geometry::Vec3r getPoint3D() const;

  virtual real getProjectedX() const;

  virtual real getProjectedY() const;

  virtual real getProjectedZ() const;

  virtual Geometry::Vec2r getPoint2D() const;

  virtual FEdge *getFEdge(Interface0D &);

  virtual Id getId() const;

  virtual Nature::VertexNature getNature() const;

  virtual SVertex *castToSVertex();

  virtual ViewVertex *castToViewVertex();

  virtual NonTVertex *castToNonTVertex();

  virtual TVertex *castToTVertex();
 
  MEM_CXX_CLASS_ALLOC_FUNCS("Freestyle:Interface0D")
};
 
//
// Interface0DIteratorNested
//
 
class Interface0DIteratorNested : public Iterator {
 public:
  virtual ~Interface0DIteratorNested() {}
 
  virtual string getExactTypeName() const
  {
    return "Interface0DIteratorNested";
  }
 
  virtual Interface0D &operator*() = 0;
 
  virtual Interface0D *operator->()
  {
    return &(operator*());
  }
 
  virtual int increment() = 0;
 
  virtual int decrement() = 0;
 
  virtual bool isBegin() const = 0;
 
  virtual bool isEnd() const = 0;
 
  virtual bool operator==(const Interface0DIteratorNested &it) const = 0;
 
  virtual bool operator!=(const Interface0DIteratorNested &it) const
  {
    return !(*this == it);
  }

  virtual float t() const = 0;

  virtual float u() const = 0;
 
  virtual Interface0DIteratorNested *copy() const = 0;
};
 
//
// Interface0DIterator
//

class Interface0DIterator : public Iterator {
 public:
  Interface0DIterator(Interface0DIteratorNested *it = nullptr)
  {
    _iterator = it;
  }

  Interface0DIterator(const Interface0DIterator &it)
  {
    _iterator = it._iterator->copy();
  }

  virtual ~Interface0DIterator()
  {
    if (_iterator) {
      delete _iterator;
    }
  }

  Interface0DIterator &operator=(const Interface0DIterator &it)
  {
    if (_iterator) {
      delete _iterator;
    }
    _iterator = it._iterator->copy();
    return *this;
  }

  virtual string getExactTypeName() const
  {
    if (!_iterator) {
      return "Interface0DIterator";
    }
    return _iterator->getExactTypeName() + "Proxy";
  }
 
  // FIXME test it != 0 (exceptions ?)

  Interface0D &operator*()
  {
    return _iterator->operator*();
  }

  Interface0D *operator->()
  {
    return &(operator*());
  }

  Interface0DIterator &operator++()
  {
    _iterator->increment();
    return *this;
  }

  Interface0DIterator operator++(int)
  {
    Interface0DIterator ret(*this);
    _iterator->increment();
    return ret;
  }

  Interface0DIterator &operator--()
  {
    _iterator->decrement();
    return *this;
  }

  Interface0DIterator operator--(int)
  {
    Interface0DIterator ret(*this);
    _iterator->decrement();
    return ret;
  }

  virtual int increment()
  {
    return _iterator->increment();
  }

  virtual int decrement()
  {
    return _iterator->decrement();
  }

  virtual bool isBegin() const
  {
    return _iterator->isBegin();
  }

  virtual bool isEnd() const
  {
    return _iterator->isEnd();
  }

  virtual bool atLast() const
  {
    if (_iterator->isEnd()) {
      return false;
    }
 
    _iterator->increment();
    bool result = _iterator->isEnd();
    _iterator->decrement();
    return result;
  }

  bool operator==(const Interface0DIterator &it) const
  {
    return _iterator->operator==(*(it._iterator));
  }

  bool operator!=(const Interface0DIterator &it) const
  {
    return !(*this == it);
  }

  inline float t() const
  {
    return _iterator->t();
  }

  inline float u() const
  {
    return _iterator->u();
  }
 
 protected:
  Interface0DIteratorNested *_iterator;
};
 
} /* namespace Freestyle */