BKE_gpencil_geom_legacy.h

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2008 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include <optional>
 
#include "BLI_bounds_types.hh"
#include "BLI_math_vector_types.hh"
 
struct Depsgraph;
struct Main;
struct Object;
struct Scene;
struct bGPDcurve;
struct bGPDlayer;
struct bGPDframe;
struct bGPDspoint;
struct bGPDstroke;
struct bGPdata;
 
/* Object bound-box. */
 
std::optional<blender::Bounds<blender::float3>> BKE_gpencil_data_minmax(const struct bGPdata *gpd);
bool BKE_gpencil_stroke_minmax(const struct bGPDstroke *gps,
                               bool use_select,
                               float r_min[3],
                               float r_max[3]);
 
void BKE_gpencil_centroid_3d(struct bGPdata *gpd, float r_centroid[3]);
void BKE_gpencil_stroke_boundingbox_calc(struct bGPDstroke *gps);
 
/* Stroke geometry utilities. */
 
void BKE_gpencil_stroke_normal(const struct bGPDstroke *gps, float r_normal[3]);
 
bool BKE_gpencil_stroke_trim(struct bGPdata *gpd, struct bGPDstroke *gps);
 
void BKE_gpencil_stroke_2d_flat(const struct bGPDspoint *points,
                                int totpoints,
                                float (*points2d)[2],
                                int *r_direction);
void BKE_gpencil_stroke_2d_flat_ref(const struct bGPDspoint *ref_points,
                                    int ref_totpoints,
                                    const struct bGPDspoint *points,
                                    int totpoints,
                                    float (*points2d)[2],
                                    float scale,
                                    int *r_direction);
void BKE_gpencil_stroke_fill_triangulate(struct bGPDstroke *gps);
void BKE_gpencil_stroke_geometry_update(struct bGPdata *gpd, struct bGPDstroke *gps);
void BKE_gpencil_stroke_uv_update(struct bGPDstroke *gps);
 
void BKE_gpencil_transform(struct bGPdata *gpd, const float mat[4][4]);
 
typedef struct GPencilPointCoordinates {
  /* This is used when doing "move only origin" in object_data_transform.cc.
   * pressure is needs to be stored here as it is tied to object scale. */
  float co[3];
  float pressure;
} GPencilPointCoordinates;
 
int BKE_gpencil_stroke_point_count(const struct bGPdata *gpd);
void BKE_gpencil_point_coords_get(struct bGPdata *gpd, GPencilPointCoordinates *elem_data);
void BKE_gpencil_point_coords_apply(struct bGPdata *gpd, const GPencilPointCoordinates *elem_data);
void BKE_gpencil_point_coords_apply_with_mat4(struct bGPdata *gpd,
                                              const GPencilPointCoordinates *elem_data,
                                              const float mat[4][4]);
 
bool BKE_gpencil_stroke_smooth_point(struct bGPDstroke *gps,
                                     int point_index,
                                     float influence,
                                     int iterations,
                                     bool smooth_caps,
                                     bool keep_shape,
                                     struct bGPDstroke *r_gps);
bool BKE_gpencil_stroke_smooth_strength(struct bGPDstroke *gps,
                                        int point_index,
                                        float influence,
                                        int iterations,
                                        struct bGPDstroke *r_gps);
bool BKE_gpencil_stroke_smooth_thickness(struct bGPDstroke *gps,
                                         int point_index,
                                         float influence,
                                         int iterations,
                                         struct bGPDstroke *r_gps);
bool BKE_gpencil_stroke_smooth_uv(struct bGPDstroke *gps,
                                  int point_index,
                                  float influence,
                                  int iterations,
                                  struct bGPDstroke *r_gps);
void BKE_gpencil_stroke_smooth(struct bGPDstroke *gps,
                               const float influence,
                               const int iterations,
                               const bool smooth_position,
                               const bool smooth_strength,
                               const bool smooth_thickness,
                               const bool smooth_uv,
                               const bool keep_shape,
                               const float *weights);
bool BKE_gpencil_stroke_close(struct bGPDstroke *gps);
 
struct bGPDstroke *BKE_gpencil_stroke_delete_tagged_points(struct bGPdata *gpd,
                                                           struct bGPDframe *gpf,
                                                           struct bGPDstroke *gps,
                                                           struct bGPDstroke *next_stroke,
                                                           int tag_flags,
                                                           bool select,
                                                           bool flat_cap,
                                                           int limit);
 
void BKE_gpencil_stroke_flip(struct bGPDstroke *gps);
 
float BKE_gpencil_stroke_length(const struct bGPDstroke *gps, bool use_3d);
float BKE_gpencil_stroke_segment_length(const struct bGPDstroke *gps,
                                        int start_index,
                                        int end_index,
                                        bool use_3d);
 
void BKE_gpencil_stroke_set_random_color(struct bGPDstroke *gps);
 
void BKE_gpencil_stroke_join(struct bGPDstroke *gps_a,
                             struct bGPDstroke *gps_b,
                             bool leave_gaps,
                             bool fit_thickness,
                             bool smooth,
                             bool auto_flip);
 
void BKE_gpencil_stroke_to_view_space(struct bGPDstroke *gps,
                                      float viewmat[4][4],
                                      const float diff_mat[4][4]);
void BKE_gpencil_stroke_from_view_space(struct bGPDstroke *gps,
                                        float viewinv[4][4],
                                        const float diff_mat[4][4]);
float BKE_gpencil_stroke_average_pressure_get(struct bGPDstroke *gps);
bool BKE_gpencil_stroke_is_pressure_constant(struct bGPDstroke *gps);