obj_export_mesh.hh

Go to the documentation of this file.

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

 
#pragma once
 
#include "BLI_math_matrix_types.hh"
#include "BLI_math_vector_types.hh"
#include "BLI_offset_indices.hh"
#include "BLI_utility_mixins.hh"
#include "BLI_vector.hh"
#include "BLI_virtual_array.hh"
 
#include "DNA_material_types.h"
#include "DNA_object_types.h"
 
#include "IO_wavefront_obj.hh"
 
namespace blender::io::obj {
const int NOT_FOUND = -1;
const int NEGATIVE_INIT = -10;
 
class OBJMesh : NonCopyable {
 private:
  std::string object_name_;
  const Mesh *export_mesh_;
  Mesh *owned_export_mesh_ = nullptr;
  Span<int2> mesh_edges_;
  OffsetIndices<int> mesh_faces_;
  Span<int> mesh_corner_verts_;
  VArray<bool> sharp_faces_;

  float4x4 world_and_axes_transform_;
  float3x3 world_and_axes_normal_transform_;
  bool mirrored_transform_;

  Array<int> corner_to_uv_index_;
  Vector<float2> uv_coords_;

  Array<int> corner_to_normal_index_;
  Array<float3> normal_coords_;
  int tot_smooth_groups_ = NEGATIVE_INIT;
  int *face_smooth_groups_ = nullptr;
  Array<int> face_order_;
 
 public:
  Array<const Material *> materials;

  OBJMesh(Depsgraph *depsgraph, const OBJExportParams &export_params, Object *mesh_object);
  ~OBJMesh();
 
  /* Clear various arrays to release potentially large memory allocations. */
  void clear();
 
  int tot_vertices() const;
  int tot_faces() const;
  int tot_uv_vertices() const;
  int tot_edges() const;
  int tot_deform_groups() const;
  bool is_mirrored_transform() const
  {
    return mirrored_transform_;
  }

  int16_t tot_materials() const;

  void calc_smooth_groups(bool use_bitflags);
  int ith_smooth_group(int face_index) const;
  bool is_ith_face_smooth(int face_index) const;

  StringRef get_object_name() const;
  StringRef get_object_mesh_name() const;
 
  const float4x4 &get_world_axes_transform() const
  {
    return world_and_axes_transform_;
  }

  Span<int> calc_face_vert_indices(const int face_index) const
  {
    return mesh_corner_verts_.slice(mesh_faces_[face_index]);
  }

  void store_uv_coords_and_indices();
  /* Get UV coordinates computed by store_uv_coords_and_indices. */
  Span<float2> get_uv_coords() const
  {
    return uv_coords_;
  }
  Span<int> get_face_uv_indices(const int face_index) const
  {
    if (uv_coords_.is_empty()) {
      return {};
    }
    BLI_assert(face_index < mesh_faces_.size());
    return corner_to_uv_index_.as_span().slice(mesh_faces_[face_index]);
  }

  void store_normal_coords_and_indices();
  /* Get normals calculate by store_normal_coords_and_indices. */
  Span<float3> get_normal_coords() const
  {
    return normal_coords_;
  }

  Span<int> get_face_normal_indices(const int face_index) const
  {
    if (corner_to_normal_index_.is_empty()) {
      return {};
    }
    const IndexRange face = mesh_faces_[face_index];
    return corner_to_normal_index_.as_span().slice(face);
  }

  int16_t get_face_deform_group_index(int face_index, MutableSpan<float> group_weights) const;
  const char *get_face_deform_group_name(int16_t def_group_index) const;

  void calc_face_order();

  int remap_face_index(int i) const
  {
    return i < 0 || i >= face_order_.size() ? i : face_order_[i];
  }
 
  const Mesh *get_mesh() const
  {
    return export_mesh_;
  }
 
 private:
  void set_mesh(Mesh *mesh);
  void triangulate_mesh_eval();
  void set_world_axes_transform(const Object &obj_eval,
                                eIOAxis forward,
                                eIOAxis up,
                                float global_scale,
                                bool apply_transform);
};
}  // namespace blender::io::obj