GEO_uv_parametrizer.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_sys_types.h" /* for intptr_t support */
 
namespace slim {
struct MatrixTransfer;
}
 
struct GHash;
struct Heap;
struct MemArena;
struct RNG;
 
namespace blender::geometry {
 
struct PChart;
struct PHash;
 
using ParamKey = uintptr_t; /* Key (hash) for identifying verts and faces. */
#define PARAM_KEY_MAX UINTPTR_MAX
 
enum PHandleState {
  PHANDLE_STATE_ALLOCATED,
  PHANDLE_STATE_CONSTRUCTED,
  PHANDLE_STATE_LSCM,
  PHANDLE_STATE_STRETCH,
};
 
class ParamHandle {
 public:
  ParamHandle();
  ~ParamHandle();
 
  PHandleState state = PHANDLE_STATE_ALLOCATED;
  MemArena *arena = nullptr;
  MemArena *polyfill_arena = nullptr;
  Heap *polyfill_heap = nullptr;
 
  PChart *construction_chart = nullptr;
  PHash *hash_verts = nullptr;
  PHash *hash_edges = nullptr;
  PHash *hash_faces = nullptr;
 
  GHash *pin_hash = nullptr;
  int unique_pin_count = 0;
 
  PChart **charts = nullptr;
  int ncharts = 0;
 
  float aspect_y = 1.0f;
 
  RNG *rng = nullptr;
  float blend = 0.0f;
 
  /* SLIM uv unwrapping */
  slim::MatrixTransfer *slim_mt = nullptr;
};
 
/* -------------------------------------------------------------------- */
void uv_parametrizer_aspect_ratio(ParamHandle *handle, float aspect_y);
 
void uv_prepare_pin_index(ParamHandle *handle, const int bmvertindex, const float uv[2]);
 
ParamKey uv_find_pin_index(ParamHandle *handle, const int bmvertindex, const float uv[2]);
 
void uv_parametrizer_face_add(ParamHandle *handle,
                              const ParamKey key,
                              const int nverts,
                              const ParamKey *vkeys,
                              const float **co,
                              float **uv, /* Output will eventually be written to `uv`. */
                              const float *weight,
                              const bool *pin,
                              const bool *select);
 
void uv_parametrizer_edge_set_seam(ParamHandle *phandle, const ParamKey *vkeys);
 
void uv_parametrizer_construct_end(ParamHandle *phandle,
                                   bool fill_holes,
                                   bool topology_from_uvs,
                                   int *r_count_failed = nullptr);
 
/* -------------------------------------------------------------------- */
struct ParamSlimOptions {
  float weight_influence = 0.0f;
  int iterations = 0;
  bool no_flip = false;
  bool skip_init = false;
};
 
void uv_parametrizer_slim_solve(ParamHandle *phandle,
                                const ParamSlimOptions *slim_options,
                                int *count_changed,
                                int *count_failed);
 
void uv_parametrizer_slim_live_begin(ParamHandle *phandle, const ParamSlimOptions *slim_options);
void uv_parametrizer_slim_live_solve_iteration(ParamHandle *phandle);
void uv_parametrizer_slim_live_end(ParamHandle *phandle);
void uv_parametrizer_slim_stretch_iteration(ParamHandle *phandle, float blend);
bool uv_parametrizer_is_slim(const ParamHandle *phandle);
 
/* -------------------------------------------------------------------- */
void uv_parametrizer_lscm_begin(ParamHandle *handle, bool live, bool abf);
void uv_parametrizer_lscm_solve(ParamHandle *handle, int *count_changed, int *count_failed);
void uv_parametrizer_lscm_end(ParamHandle *handle);
 
/* -------------------------------------------------------------------- */
void uv_parametrizer_stretch_begin(ParamHandle *handle);
void uv_parametrizer_stretch_blend(ParamHandle *handle, float blend);
void uv_parametrizer_stretch_iter(ParamHandle *handle);
void uv_parametrizer_stretch_end(ParamHandle *handle);
 
/* -------------------------------------------------------------------- */
void uv_parametrizer_pack(ParamHandle *handle, float margin, bool do_rotate, bool ignore_pinned);
 
/* -------------------------------------------------------------------- */
void uv_parametrizer_average(ParamHandle *handle, bool ignore_pinned, bool scale_uv, bool shear);
 
/* -------------------------------------------------------------------- */
void uv_parametrizer_flush(ParamHandle *handle);
void uv_parametrizer_flush_restore(ParamHandle *handle);
 
}  // namespace blender::geometry