Commit 388fd79e authored by Philip Trettner's avatar Philip Trettner
Browse files

refactoring, new interface paradigm

parent 84187a66
#pragma once
#include "EdgeIndex.hh"
namespace polymesh
{
struct Mesh;
struct EdgeHandle
{
Mesh const* mesh;
EdgeIndex idx;
EdgeHandle(Mesh const* mesh, EdgeIndex idx) : mesh(mesh), idx(idx) {}
};
}
#pragma once
namespace polymesh
{
struct EdgeIndex
{
int value = -1;
EdgeIndex() = default;
explicit EdgeIndex(int idx) : value(idx) {}
bool is_valid() const { return value >= 0; }
static EdgeIndex invalid() { return {}; }
bool operator==(EdgeIndex const& rhs) const { return value == rhs.value; }
bool operator!=(EdgeIndex const& rhs) const { return value != rhs.value; }
};
}
#pragma once
#include "FaceIndex.hh"
namespace polymesh
{
struct Mesh;
struct FaceHandle
{
Mesh const* mesh;
FaceIndex idx;
FaceHandle(Mesh const* mesh, FaceIndex idx) : mesh(mesh), idx(idx) {}
};
}
#pragma once
namespace polymesh
{
struct FaceIndex
{
int value = -1;
FaceIndex() = default;
explicit FaceIndex(int idx) : value(idx) {}
bool is_valid() const { return value >= 0; }
static FaceIndex invalid() { return {}; }
bool operator==(FaceIndex const& rhs) const { return value == rhs.value; }
bool operator!=(FaceIndex const& rhs) const { return value != rhs.value; }
};
}
#pragma once
#include "HalfedgeIndex.hh"
namespace polymesh
{
struct Mesh;
struct HalfedgeHandle
{
Mesh const* mesh;
HalfedgeIndex idx;
HalfedgeHandle(Mesh const* mesh, HalfedgeIndex idx) : mesh(mesh), idx(idx) {}
};
}
#pragma once
namespace polymesh
{
struct HalfedgeIndex
{
int value = -1;
HalfedgeIndex() = default;
explicit HalfedgeIndex(int idx) : value(idx) {}
bool is_valid() const { return value >= 0; }
static HalfedgeIndex invalid() { return {}; }
bool operator==(HalfedgeIndex const& rhs) const { return value == rhs.value; }
bool operator!=(HalfedgeIndex const& rhs) const { return value != rhs.value; }
};
}
#pragma once
#include <cassert>
#include "EdgeHandle.hh"
#include "FaceHandle.hh"
#include "HalfedgeHandle.hh"
#include "VertexHandle.hh"
// For iterator interfaces, see http://anderberg.me/2016/07/04/c-custom-iterators/
// Note: some iterator methods are implemented at the end of Mesh.hh to ensure inlining
namespace polymesh
{
struct skipping_vertex_iterator
{
skipping_vertex_iterator() = default;
skipping_vertex_iterator(VertexHandle handle) : handle(handle) {}
VertexHandle operator*() const { return handle; }
skipping_vertex_iterator& operator++();
skipping_vertex_iterator operator++(int)
{
auto i = *this;
return ++i;
}
bool operator==(skipping_vertex_iterator const& rhs) const
{
assert(handle.mesh == rhs.handle.mesh && "comparing iterators from different meshes");
return handle.idx == rhs.handle.idx;
}
bool operator!=(skipping_vertex_iterator const& rhs) const
{
assert(handle.mesh == rhs.handle.mesh && "comparing iterators from different meshes");
return handle.idx != rhs.handle.idx;
}
private:
VertexHandle handle;
};
struct vertex_iterator
{
vertex_iterator() = default;
vertex_iterator(VertexHandle handle) : handle(handle) {}
VertexHandle operator*() const { return handle; }
vertex_iterator& operator++();
vertex_iterator operator++(int)
{
auto i = *this;
return ++i;
}
bool operator==(vertex_iterator const& rhs) const
{
assert(handle.mesh == rhs.handle.mesh && "comparing iterators from different meshes");
return handle.idx == rhs.handle.idx;
}
bool operator!=(vertex_iterator const& rhs) const
{
assert(handle.mesh == rhs.handle.mesh && "comparing iterators from different meshes");
return handle.idx != rhs.handle.idx;
}
private:
VertexHandle handle;
};
}
This diff is collapsed.
#pragma once
#include "Iterators.hh"
namespace polymesh
{
template<typename IteratorT>
struct iterator_range
{
IteratorT _begin;
IteratorT _end;
IteratorT begin() const { return _begin; }
IteratorT end() const { return _end; }
};
using vertex_range = iterator_range<vertex_iterator>;
using skipping_vertex_range = iterator_range<skipping_vertex_iterator>;
}
#pragma once
#include "VertexIndex.hh"
namespace polymesh
{
struct Mesh;
struct VertexHandle
{
Mesh const* mesh;
VertexIndex idx;
VertexHandle(Mesh const* mesh, VertexIndex idx) : mesh(mesh), idx(idx) {}
};
}
#pragma once
namespace polymesh
{
struct VertexIndex
{
int value = -1;
VertexIndex() = default;
explicit VertexIndex(int idx) : value(idx) {}
bool is_valid() const { return value >= 0; }
static VertexIndex invalid() { return {}; }
bool operator==(VertexIndex const& rhs) const { return value == rhs.value; }
bool operator!=(VertexIndex const& rhs) const { return value != rhs.value; }
};
}
#pragma once
namespace polymesh
{
struct Mesh;
// ======================== INDICES ========================
struct face_index
{
int value = -1;
face_index() = default;
explicit face_index(int idx) : value(idx) {}
bool is_valid() const { return value >= 0; }
static face_index invalid() { return {}; }
bool operator==(face_index const& rhs) const { return value == rhs.value; }
bool operator!=(face_index const& rhs) const { return value != rhs.value; }
};
struct vertex_index
{
int value = -1;
vertex_index() = default;
explicit vertex_index(int idx) : value(idx) {}
bool is_valid() const { return value >= 0; }
static vertex_index invalid() { return {}; }
bool operator==(vertex_index const& rhs) const { return value == rhs.value; }
bool operator!=(vertex_index const& rhs) const { return value != rhs.value; }
};
struct edge_index
{
int value = -1;
edge_index() = default;
explicit edge_index(int idx) : value(idx) {}
bool is_valid() const { return value >= 0; }
static edge_index invalid() { return {}; }
bool operator==(edge_index const& rhs) const { return value == rhs.value; }
bool operator!=(edge_index const& rhs) const { return value != rhs.value; }
};
struct halfedge_index
{
int value = -1;
halfedge_index() = default;
explicit halfedge_index(int idx) : value(idx) {}
bool is_valid() const { return value >= 0; }
static halfedge_index invalid() { return {}; }
bool operator==(halfedge_index const& rhs) const { return value == rhs.value; }
bool operator!=(halfedge_index const& rhs) const { return value != rhs.value; }
};
// ======================== HANDLES ========================
struct face_handle
{
Mesh const* mesh;
face_index idx;
face_handle(Mesh const* mesh, face_index idx) : mesh(mesh), idx(idx) {}
bool operator==(face_index const& rhs) const { return idx == rhs; }
bool operator!=(face_index const& rhs) const { return idx != rhs; }
bool operator==(face_handle const& rhs) const { return mesh == rhs.mesh && idx == rhs.idx; }
bool operator!=(face_handle const& rhs) const { return mesh != rhs.mesh || idx != rhs.idx; }
};
struct vertex_handle
{
Mesh const* mesh;
vertex_index idx;
vertex_handle(Mesh const* mesh, vertex_index idx) : mesh(mesh), idx(idx) {}
bool operator==(vertex_index const& rhs) const { return idx == rhs; }
bool operator!=(vertex_index const& rhs) const { return idx != rhs; }
bool operator==(vertex_handle const& rhs) const { return mesh == rhs.mesh && idx == rhs.idx; }
bool operator!=(vertex_handle const& rhs) const { return mesh != rhs.mesh || idx != rhs.idx; }
};
struct edge_handle
{
Mesh const* mesh;
edge_index idx;
edge_handle(Mesh const* mesh, edge_index idx) : mesh(mesh), idx(idx) {}
bool operator==(edge_index const& rhs) const { return idx == rhs; }
bool operator!=(edge_index const& rhs) const { return idx != rhs; }
bool operator==(edge_handle const& rhs) const { return mesh == rhs.mesh && idx == rhs.idx; }
bool operator!=(edge_handle const& rhs) const { return mesh != rhs.mesh || idx != rhs.idx; }
};
struct halfedge_handle
{
Mesh const* mesh;
halfedge_index idx;
halfedge_handle(Mesh const* mesh, halfedge_index idx) : mesh(mesh), idx(idx) {}
bool operator==(halfedge_index const& rhs) const { return idx == rhs; }
bool operator!=(halfedge_index const& rhs) const { return idx != rhs; }
bool operator==(halfedge_handle const& rhs) const { return mesh == rhs.mesh && idx == rhs.idx; }
bool operator!=(halfedge_handle const& rhs) const { return mesh != rhs.mesh || idx != rhs.idx; }
};
}
#pragma once
#include <cassert>
#include "cursors.hh"
// For iterator interfaces, see http://anderberg.me/2016/07/04/c-custom-iterators/
// Note: some iterator methods are implemented at the end of Mesh.hh to ensure inlining
namespace polymesh
{
struct valid_vertex_iterator
{
valid_vertex_iterator() = default;
valid_vertex_iterator(vertex_handle handle) : handle(handle) {}
vertex_handle operator*() const { return handle; }
valid_vertex_iterator& operator++();
valid_vertex_iterator operator++(int)
{
auto i = *this;
return ++i;
}
bool operator==(valid_vertex_iterator const& rhs) const
{
assert(handle.mesh == rhs.handle.mesh && "comparing iterators from different meshes");
return handle.idx == rhs.handle.idx;
}
bool operator!=(valid_vertex_iterator const& rhs) const
{
assert(handle.mesh == rhs.handle.mesh && "comparing iterators from different meshes");
return handle.idx != rhs.handle.idx;
}
private:
vertex_handle handle;
};
struct vertex_iterator
{
vertex_iterator() = default;
vertex_iterator(vertex_handle handle) : handle(handle) {}
vertex_handle operator*() const { return handle; }
vertex_iterator& operator++();
vertex_iterator operator++(int)
{
auto i = *this;
return ++i;
}
bool operator==(vertex_iterator const& rhs) const
{
assert(handle.mesh == rhs.handle.mesh && "comparing iterators from different meshes");
return handle.idx == rhs.handle.idx;
}
bool operator!=(vertex_iterator const& rhs) const
{
assert(handle.mesh == rhs.handle.mesh && "comparing iterators from different meshes");
return handle.idx != rhs.handle.idx;
}
private:
vertex_handle handle;
};
struct valid_face_iterator
{
valid_face_iterator() = default;
valid_face_iterator(face_handle handle) : handle(handle) {}
face_handle operator*() const { return handle; }
valid_face_iterator& operator++();
valid_face_iterator operator++(int)
{
auto i = *this;
return ++i;
}
bool operator==(valid_face_iterator const& rhs) const
{
assert(handle.mesh == rhs.handle.mesh && "comparing iterators from different meshes");
return handle.idx == rhs.handle.idx;
}
bool operator!=(valid_face_iterator const& rhs) const
{
assert(handle.mesh == rhs.handle.mesh && "comparing iterators from different meshes");
return handle.idx != rhs.handle.idx;
}
private:
face_handle handle;
};
struct face_iterator
{
face_iterator() = default;
face_iterator(face_handle handle) : handle(handle) {}
face_handle operator*() const { return handle; }
face_iterator& operator++();
face_iterator operator++(int)
{
auto i = *this;
return ++i;
}
bool operator==(face_iterator const& rhs) const
{
assert(handle.mesh == rhs.handle.mesh && "comparing iterators from different meshes");
return handle.idx == rhs.handle.idx;
}
bool operator!=(face_iterator const& rhs) const
{
assert(handle.mesh == rhs.handle.mesh && "comparing iterators from different meshes");
return handle.idx != rhs.handle.idx;
}
private:
face_handle handle;
};
struct valid_edge_iterator
{
valid_edge_iterator() = default;
valid_edge_iterator(edge_handle handle) : handle(handle) {}
edge_handle operator*() const { return handle; }
valid_edge_iterator& operator++();
valid_edge_iterator operator++(int)
{
auto i = *this;
return ++i;
}
bool operator==(valid_edge_iterator const& rhs) const
{
assert(handle.mesh == rhs.handle.mesh && "comparing iterators from different meshes");
return handle.idx == rhs.handle.idx;
}
bool operator!=(valid_edge_iterator const& rhs) const
{
assert(handle.mesh == rhs.handle.mesh && "comparing iterators from different meshes");
return handle.idx != rhs.handle.idx;
}
private:
edge_handle handle;
};
struct edge_iterator
{
edge_iterator() = default;
edge_iterator(edge_handle handle) : handle(handle) {}
edge_handle operator*() const { return handle; }
edge_iterator& operator++();
edge_iterator operator++(int)
{
auto i = *this;
return ++i;
}
bool operator==(edge_iterator const& rhs) const
{
assert(handle.mesh == rhs.handle.mesh && "comparing iterators from different meshes");
return handle.idx == rhs.handle.idx;
}
bool operator!=(edge_iterator const& rhs) const
{
assert(handle.mesh == rhs.handle.mesh && "comparing iterators from different meshes");
return handle.idx != rhs.handle.idx;
}
private:
edge_handle handle;
};
struct valid_halfedge_iterator
{
valid_halfedge_iterator() = default;
valid_halfedge_iterator(halfedge_handle handle) : handle(handle) {}
halfedge_handle operator*() const { return handle; }
valid_halfedge_iterator& operator++();
valid_halfedge_iterator operator++(int)
{
auto i = *this;
return ++i;
}
bool operator==(valid_halfedge_iterator const& rhs) const
{
assert(handle.mesh == rhs.handle.mesh && "comparing iterators from different meshes");
return handle.idx == rhs.handle.idx;
}
bool operator!=(valid_halfedge_iterator const& rhs) const
{
assert(handle.mesh == rhs.handle.mesh && "comparing iterators from different meshes");
return handle.idx != rhs.handle.idx;
}
private:
halfedge_handle handle;
};
struct halfedge_iterator
{
halfedge_iterator() = default;
halfedge_iterator(halfedge_handle handle) : handle(handle) {}
halfedge_handle operator*() const { return handle; }
halfedge_iterator& operator++();
halfedge_iterator operator++(int)
{
auto i = *this;
return ++i;
}
bool operator==(halfedge_iterator const& rhs) const
{
assert(handle.mesh == rhs.handle.mesh && "comparing iterators from different meshes");
return handle.idx == rhs.handle.idx;
}
bool operator!=(halfedge_iterator const& rhs) const
{
assert(handle.mesh == rhs.handle.mesh && "comparing iterators from different meshes");
return handle.idx != rhs.handle.idx;
}
private:
halfedge_handle handle;
};
}
#pragma once
#include <cstddef>
#include <vector>
#include "iterators.hh"
namespace polymesh
{
/// Collection of all vertices of a mesh, including deleted ones
/// Basically a smart std::vector
struct vertex_collection
{
Mesh* mesh;
/// Number of vertices, INCLUDING deleted/invalid ones
/// O(1) computation
int size() const;
/// Ensures that a given number of vertices can be stored without reallocation
void reserve(int capacity) const;
/// Adds a new vertex and returns its handle