[Bf-blender-cvs] [8cad95d10bd] soc-2019-fast-io: [Fast import/export] Fixed crash related to normal_iter and incorrect default aixs remapping behaviour
Hugo Sales
noreply at git.blender.org
Wed Jul 3 17:30:46 CEST 2019
Commit: 8cad95d10bdb4d8ea39d4aa0ceb2f2ac07dc5f3b
Author: Hugo Sales
Date: Wed Jul 3 16:18:49 2019 +0100
Branches: soc-2019-fast-io
https://developer.blender.org/rB8cad95d10bdb4d8ea39d4aa0ceb2f2ac07dc5f3b
[Fast import/export] Fixed crash related to normal_iter and incorrect default aixs remapping behaviour
===================================================================
M source/blender/editors/io/intern/common.cpp
M source/blender/editors/io/intern/iterators.hpp
M source/blender/editors/io/intern/obj.cpp
M source/blender/editors/io/io_obj.c
===================================================================
diff --git a/source/blender/editors/io/intern/common.cpp b/source/blender/editors/io/intern/common.cpp
index 2a29da7bc2a..c949ff3cc3c 100644
--- a/source/blender/editors/io/intern/common.cpp
+++ b/source/blender/editors/io/intern/common.cpp
@@ -32,25 +32,31 @@ extern "C" {
// Anonymous namespace for internal functions
namespace {
-inline void change_single_axis_orientation(float (&mat)[4][4], int axis_from, int axis_to)
+inline bool axis_enum_to_index(int &axis)
{
- bool negate = false;
- switch (axis_to) {
+ switch (axis) {
case AXIS_X: // Fallthrough
case AXIS_Y: // Fallthrough
case AXIS_Z:
- break; // Just swap
+ return false; // Just swap
case AXIS_NEG_X: // Fallthrough
case AXIS_NEG_Y: // Fallthrough
case AXIS_NEG_Z:
- axis_to -= AXIS_NEG_X; // Transform the enum into an index
- negate = true; // Swap and negate
- break;
+ axis -= AXIS_NEG_X; // Transform the enum into an index
+ return true; // Swap and negate
+ default:
+ return false;
}
+}
+
+inline void change_single_axis_orientation(float (&mat)[4][4], int axis_from, int axis_to)
+{
+ bool negate = axis_enum_to_index(axis_to);
+
for (size_t i = 0; i < 4; ++i) {
- float t = mat[i][axis_to];
- mat[i][axis_to] = (negate ? -1 : 1) * mat[i][axis_from];
- mat[i][axis_from] = t;
+ float t = mat[axis_to][i];
+ mat[axis_to][i] = (negate ? -1 : 1) * mat[axis_from][i];
+ mat[axis_from][i] = t;
}
}
} // namespace
@@ -120,8 +126,14 @@ bool should_export_object(const ExportSettings *const settings, const Object *co
void change_orientation(float (&mat)[4][4], int forward, int up)
{
- change_single_axis_orientation(mat, AXIS_X, forward);
- change_single_axis_orientation(mat, AXIS_Z, up);
+ change_single_axis_orientation(mat, AXIS_Y, AXIS_NEG_Z); // Works
+ // change_single_axis_orientation(mat, AXIS_X, up);
+
+ // change_single_axis_orientation(mat, AXIS_X, forward);
+ // change_single_axis_orientation(mat, AXIS_X, up);
+
+ // set_single_axis(mat, AXIS_Z, up);
+ // set_single_axis(mat, AXIS_Y, forward);
}
float get_unit_scale(const Scene *const scene)
diff --git a/source/blender/editors/io/intern/iterators.hpp b/source/blender/editors/io/intern/iterators.hpp
index 60379dbd438..ff188957f82 100644
--- a/source/blender/editors/io/intern/iterators.hpp
+++ b/source/blender/editors/io/intern/iterators.hpp
@@ -42,6 +42,9 @@ template<typename T, typename Tag = std::random_access_iterator_tag> struct poin
pointer_iterator_base(pointer p, size_t size) : first(p), curr(p), size(size)
{
}
+ pointer_iterator_base(pointer p, size_t size, pointer first) : first(first), curr(p), size(size)
+ {
+ }
pointer_iterator_base(const pointer_iterator_base &pib)
: first(pib.first), curr(pib.curr), size(pib.size)
{
@@ -60,11 +63,11 @@ template<typename T, typename Tag = std::random_access_iterator_tag> struct poin
}
pointer_iterator_base begin() const
{
- return {this->first, this->size};
+ return {this->first, this->size, this->first};
}
pointer_iterator_base end() const
{
- return {this->first + this->size, this->size};
+ return {this->first + this->size, this->size, this->first};
}
pointer_iterator_base &operator++()
{
@@ -97,6 +100,10 @@ template<typename T, typename Tag = std::random_access_iterator_tag> struct poin
template<typename T>
struct pointer_iterator : pointer_iterator_base<T, std::random_access_iterator_tag> {
using pointer_iterator_base<T, std::random_access_iterator_tag>::pointer_iterator_base;
+ pointer_iterator(const pointer_iterator_base<T, std::random_access_iterator_tag> &pi)
+ : pointer_iterator_base<T, std::random_access_iterator_tag>(pi)
+ {
+ }
inline const T &operator*() const
{
return *this->curr;
@@ -152,19 +159,17 @@ struct poly_iter : pointer_iterator<MPoly> {
poly_iter(const Mesh *const m) : pointer_iterator(m->mpoly, m->totpoly)
{
}
- poly_iter(MPoly *const poly, size_t size) : pointer_iterator(poly, size)
+ poly_iter(const pointer_iterator_base<MPoly> &pi) : pointer_iterator(pi)
{
}
poly_iter begin() const
{
- return {this->first, this->size};
+ return {{this->first, this->size, this->first}};
}
poly_iter end() const
{
- return {this->first + this->size, this->size};
+ return {{this->first + this->size, this->size, this->first}};
}
- // poly_iter(const pointer_iterator &p) : pointer_iterator(p) {}
- // poly_iter(pointer_iterator &&p) : pointer_iterator(std::move(p)) {}
};
// Iterator over the vertices of a mesh
@@ -180,17 +185,17 @@ struct transformed_vertex_iter : pointer_iterator_base<MVert> {
: pointer_iterator_base(m->mvert, m->totvert), mat(mat)
{
}
- transformed_vertex_iter(MVert *const mvert, size_t size, Mat &mat)
- : pointer_iterator_base(mvert, size), mat(mat)
+ transformed_vertex_iter(const pointer_iterator_base<MVert> &pi, Mat &mat)
+ : pointer_iterator_base(pi), mat(mat)
{
}
transformed_vertex_iter begin() const
{
- return {this->first, this->size, mat};
+ return {{this->first, this->size, this->first}, mat};
}
transformed_vertex_iter end() const
{
- return {this->first + this->size, this->size, mat};
+ return {{this->first + this->size, this->size, this->first}, mat};
}
const std::array<float, 3> operator*() const
{
@@ -208,17 +213,18 @@ struct vert_of_poly_iter : pointer_iterator_base<MLoop, std::random_access_itera
: pointer_iterator_base(mesh->mloop + mp.loopstart, mp.totloop), mvert(mesh->mvert)
{
}
- vert_of_poly_iter(const MVert *const mvert, MLoop *poly, size_t size)
- : pointer_iterator_base(poly, size), mvert(mvert)
+ vert_of_poly_iter(const MVert *const mvert,
+ const pointer_iterator_base<MLoop, std::random_access_iterator_tag> &pi)
+ : pointer_iterator_base(pi), mvert(mvert)
{
}
vert_of_poly_iter begin() const
{
- return {mvert, this->first, this->size};
+ return {mvert, {this->first, this->size, this->first}};
}
vert_of_poly_iter end() const
{
- return {mvert, this->first + this->size, this->size};
+ return {mvert, {this->first + this->size, this->size, this->first}};
}
const MVert &operator*() const
{
@@ -232,11 +238,9 @@ struct edge_iter : pointer_iterator<MEdge> {
edge_iter(const Mesh *const m) : pointer_iterator(m->medge, m->totedge)
{
}
- edge_iter(MEdge *const e, size_t s) : pointer_iterator(e, s)
+ edge_iter(const pointer_iterator<MEdge> &pi) : pointer_iterator(pi)
{
}
- // edge_iter(const pointer_iterator<MEdge> &pi) : pointer_iterator(pi) {}
- // edge_iter(pointer_iterator<MEdge> &&pi) : pointer_iterator(pi) {}
};
// Iterator over the edges of a mesh which are marked as loose
@@ -244,16 +248,16 @@ struct loose_edge_iter : edge_iter {
loose_edge_iter(const Mesh *const m) : edge_iter(m)
{
}
- loose_edge_iter(MEdge *const e, size_t s) : edge_iter(e, s)
+ loose_edge_iter(const pointer_iterator<MEdge> &pi) : edge_iter(pi)
{
}
loose_edge_iter begin() const
{
- return {this->first, this->size};
+ return {{this->first, this->size, this->first}};
}
loose_edge_iter end() const
{
- return {this->first + this->size, this->size};
+ return {{this->first + this->size, this->size, this->first}};
}
loose_edge_iter &operator++()
{
@@ -330,19 +334,17 @@ struct loop_of_poly_iter : pointer_iterator<MLoop> {
: pointer_iterator(mesh->mloop + poly.loopstart, poly.totloop)
{
}
- loop_of_poly_iter(MLoop *const loop, size_t size) : pointer_iterator(loop, size)
+ loop_of_poly_iter(const pointer_iterator_base<MLoop> &pi) : pointer_iterator(pi)
{
}
loop_of_poly_iter begin() const
{
- return loop_of_poly_iter{this->first, this->size};
+ return loop_of_poly_iter{{this->first, this->size, this->first}};
}
loop_of_poly_iter end() const
{
- return loop_of_poly_iter{this->first + this->size, this->size};
+ return loop_of_poly_iter{{this->first + this->size, this->size, this->first}};
}
- // loop_of_poly_iter(const pointer_iterator &p) : pointer_iterator(p) {}
- // loop_of_poly_iter(pointer_iterator &&p) : pointer_iterator(std::move(p)) {}
};
struct material_iter : offset_iterator<Material *> {
@@ -387,16 +389,16 @@ struct points_of_nurbs_iter : pointer_iterator_base<BPoint> {
: pointer_iterator_base(nu->bp, (nu->pntsv > 0 ? nu->pntsu * nu->pntsv : nu->pntsu))
{
}
- points_of_nurbs_iter(BPoint *bp, size_t size) : pointer_iterator_base(bp, size)
+ points_of_nurbs_iter(const pointer_iterator_base<BPoint> &pi) : pointer_iterator_base(pi)
{
}
points_of_nurbs_iter begin() const
{
- return {this->first, this->size};
+ return {{this->first, this->size, this->first}};
}
points_of_nurbs_iter end() const
{
- return {this->first + this->size, this->size};
+ return {{this->first + this->size, this->size, this->first}};
}
inline const std::array<float, 3> operator*() const
{
@@ -409,23 +411,21 @@ struct uv_iter : pointer_iterator_base<MLoopUV> {
uv_iter(const Mesh *const m) : pointer_iterator_base(m->mloopuv, m->mloopuv ? m->totloop : 0)
{
}
- uv_iter(MLoopUV *const uv, size_t size) : pointer_iterator_base(uv, uv ? size : 0)
+ uv_iter(const pointer_iterator_base<MLoopUV> &pi) : pointer_iterator_base(pi)
{
}
uv_iter begin() const
{
- return {this->first, this->size};
+ return {{this->first, this->size, this->first}};
}
uv_iter end() const
{
- return {this->first + this->size, this->size};
+ return {{this->first + this->size, this->size, this->first}};
}
inline const std::array<float, 2> operator*()
{
return {this->curr->uv[0], this->curr->uv[1]};
}
- // uv_iter(const dereference_iterator_ &di) : dereference_iterator(di, this) {}
- // uv_iter(dereference_iterator_ &&di) : dereference_iterator(di, this) {}
};
// Iterator over the normals of mesh
@@ -437,21 +437,17 @@ struct uv_iter : pointer_iterator_base<MLoopUV> {
// It's only a bidirectional iterator, because it is not continuous
struct normal_iter {
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list