obj_export_file_writer.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_map.hh"
#include "BLI_set.hh"
#include "BLI_vector.hh"
 
#include "IO_wavefront_obj.hh"
#include "obj_export_io.hh"
#include "obj_export_mtl.hh"
 
#include <iostream>
 
namespace blender::io::obj {
 
class OBJCurve;
class OBJMesh;
struct IndexOffsets {
  int vertex_offset;
  int uv_vertex_offset;
  int normal_offset;
};
 
class OBJWriter : NonMovable, NonCopyable {
 private:
  const OBJExportParams &export_params_;
  std::string outfile_path_;
  FILE *outfile_;
 
 public:
  OBJWriter(const char *filepath, const OBJExportParams &export_params) noexcept(false)
      : export_params_(export_params), outfile_path_(filepath), outfile_(nullptr)
  {
    outfile_ = BLI_fopen(filepath, "wb");
    if (!outfile_) {
      throw std::system_error(errno, std::system_category(), "Cannot open file " + outfile_path_);
    }
  }
  ~OBJWriter()
  {
    if (outfile_ && std::fclose(outfile_)) {
      std::cerr << "Error: could not close the file '" << outfile_path_
                << "' properly, it may be corrupted." << std::endl;
    }
  }
 
  FILE *get_outfile() const
  {
    return outfile_;
  }
 
  void write_header() const;
 
  void write_object_name(FormatHandler &fh, const OBJMesh &obj_mesh_data) const;
  void write_mtllib_name(const StringRefNull mtl_filepath) const;
  void write_vertex_coords(FormatHandler &fh,
                           const OBJMesh &obj_mesh_data,
                           bool write_colors) const;
  void write_uv_coords(FormatHandler &fh, OBJMesh &obj_mesh_data) const;
  void write_normals(FormatHandler &fh, OBJMesh &obj_mesh_data);
  void write_face_elements(FormatHandler &fh,
                           const IndexOffsets &offsets,
                           const OBJMesh &obj_mesh_data,
                           FunctionRef<const char *(int)> matname_fn);
  void write_edges_indices(FormatHandler &fh,
                           const IndexOffsets &offsets,
                           const OBJMesh &obj_mesh_data) const;
  void write_nurbs_curve(FormatHandler &fh, const OBJCurve &obj_nurbs_data) const;
 
 private:
  using func_vert_uv_normal_indices = void (OBJWriter::*)(FormatHandler &fh,
                                                          const IndexOffsets &offsets,
                                                          Span<int> vert_indices,
                                                          Span<int> uv_indices,
                                                          Span<int> normal_indices,
                                                          bool flip) const;
  func_vert_uv_normal_indices get_face_element_writer(int total_uv_vertices) const;
 
  void write_vert_uv_normal_indices(FormatHandler &fh,
                                    const IndexOffsets &offsets,
                                    Span<int> vert_indices,
                                    Span<int> uv_indices,
                                    Span<int> normal_indices,
                                    bool flip) const;
  void write_vert_normal_indices(FormatHandler &fh,
                                 const IndexOffsets &offsets,
                                 Span<int> vert_indices,
                                 Span<int> /*uv_indices*/,
                                 Span<int> normal_indices,
                                 bool flip) const;
  void write_vert_uv_indices(FormatHandler &fh,
                             const IndexOffsets &offsets,
                             Span<int> vert_indices,
                             Span<int> uv_indices,
                             Span<int> /*normal_indices*/,
                             bool flip) const;
  void write_vert_indices(FormatHandler &fh,
                          const IndexOffsets &offsets,
                          Span<int> vert_indices,
                          Span<int> /*uv_indices*/,
                          Span<int> /*normal_indices*/,
                          bool flip) const;
};
 
class MTLWriter : NonMovable, NonCopyable {
 private:
  FormatHandler fmt_handler_;
  FILE *outfile_ = nullptr;
  std::string mtl_filepath_;
  Vector<MTLMaterial> mtlmaterials_;
  /* Map from a Material* to an index into mtlmaterials_. */
  Map<const Material *, int> material_map_;
 
 public:
  /*
   * Create the `.MTL` file.
   */
  MTLWriter(const char *obj_filepath, bool write_file) noexcept(false);
  ~MTLWriter();
 
  void write_header(const char *blen_filepath);
  void write_materials(const char *blen_filepath,
                       ePathReferenceMode path_mode,
                       const char *dest_dir,
                       bool write_pbr);
  StringRefNull mtl_file_path() const;
  Vector<int> add_materials(const OBJMesh &mesh_to_export);
  const char *mtlmaterial_name(int index);
 
 private:
  void write_bsdf_properties(const MTLMaterial &mtl_material, bool write_pbr);
  void write_texture_map(const MTLMaterial &mtl_material,
                         MTLTexMapType texture_key,
                         const MTLTexMap &texture_map,
                         const char *blen_filedir,
                         const char *dest_dir,
                         ePathReferenceMode mode,
                         Set<std::pair<std::string, std::string>> &copy_set);
};
}  // namespace blender::io::obj