101 "Bezier curve with straight-line segments (vector handles)"},
118 "Use the original timing, gaps included"},
123 "Use the original timing, but with custom gap lengths (in frames)"},
160 float diff_mat[4][4];
188 mvalf[0] = (
float)pt->
x / 100.0f * region->
winx;
189 mvalf[1] = (
float)pt->
y / 100.0f * region->
winy;
259 const double stroke_inittime,
261 const float delta_dist)
263 float delta_time = 0.0f;
269 gtd->
times[cur_point] = 0.0f;
271 else if (
time < 0.0f) {
275 delta_time = -gtd->
times[cur_point] - gtd->
times[cur_point - 1];
294 #define MIN_TIME_DELTA 0.02f
300 const int gaps_count,
301 int *gaps_done_count,
302 const float tot_gaps_time,
303 const float delta_time,
304 float *next_delta_time)
309 if (gtd->
times[j] < 0) {
319 int rem_gaps = gaps_count - (*gaps_done_count);
322 *next_delta_time = tot_gaps_time;
330 delta = delta_time - (gtd->
gap_duration * (*gaps_done_count));
346 (*gaps_done_count)++;
357 float *r_tot_gaps_time)
359 float delta_time = 0.0f;
362 if (gtd->
times[i] < 0 && i) {
365 delta_time += gtd->
times[i] - gtd->
times[i - 1];
369 gtd->
times[i] -= delta_time;
389 const float time_range,
390 const int gaps_count,
391 const float tot_gaps_time)
396 float last_valid_time = 0.0f;
397 int end_stroke_idx = -1, start_stroke_idx = 0;
398 float end_stroke_time = 0.0f;
401 float delta_time = 0.0f, next_delta_time = 0.0f;
402 int gaps_done_count = 0;
410 if (i > end_stroke_idx) {
411 start_stroke_idx = i;
412 delta_time = next_delta_time;
415 gtd, rng, i, gaps_count, &gaps_done_count, tot_gaps_time, delta_time, &next_delta_time);
417 end_stroke_time = time_start +
418 ((gtd->
times[end_stroke_idx] + delta_time) / gtd->
tot_time * time_range);
423 float cfra = time_start + ((gtd->
times[i] + delta_time) / gtd->
tot_time * time_range);
426 if (i == start_stroke_idx) {
446 last_valid_time = cfra;
449 else if (i == end_stroke_idx) {
464 last_valid_time = cfra;
481 last_valid_time = cfra;
485 "\t Skipping \"middle\" point %d, too close from last added point or end point %d\n",
541 &anim_eval_context_start,
559 &anim_eval_context_end,
570 float tot_gaps_time = 0.0f;
585 reports,
ptr, prop,
depsgraph, fcu, cu, gtd, rng, time_range, gaps_count, tot_gaps_time);
599 #undef MIN_TIME_DELTA
601 #define GAP_DFAC 0.01f
602 #define WIDTH_CORR_FAC 0.1f
603 #define BEZT_HANDLE_FAC 0.3f
611 const float prev_p[3],
613 const double inittime,
617 float minmax_weights[2])
627 if (bp->
weight < minmax_weights[0]) {
628 minmax_weights[0] = bp->
weight;
630 else if (bp->
weight > minmax_weights[1]) {
631 minmax_weights[1] = bp->
weight;
646 float minmax_weights[2],
649 const bool add_start_point,
650 const bool add_end_point,
657 const int add_start_end_points = (add_start_point ? 1 : 0) + (add_end_point ? 1 : 0);
701 if (curnu && !stitch && old_nbp) {
702 float p1[3], p2[3], p[3], next_p[3];
703 float dt1 = 0.0f, dt2 = 0.0f;
710 prev_bp = &nu->
bp[old_nbp - 2];
712 bp = &nu->
bp[old_nbp - 1];
758 gtd, bp, p2, p1, do_gtd, gps->
inittime, dt2, 0.0f, rad_fac, minmax_weights);
762 else if (add_start_point) {
763 float p[3], next_p[3];
778 bp = &nu->
bp[old_nbp];
784 gtd, bp, p, p, do_gtd, gps->
inittime, dt, 0.0f, rad_fac, minmax_weights);
790 prev_bp = &nu->
bp[old_nbp - 1];
794 for (i = (stitch) ? 1 : 0, pt = &gps->
points[(stitch) ? 1 : 0], bp = &nu->
bp[old_nbp];
806 (prev_bp) ? prev_bp->
vec : p,
835 gtd, bp, p, prev_bp->
vec, do_gtd, gps->
inittime, dt, 0.0f, rad_fac, minmax_weights);
839 if (!curnu || !*curnu) {
857 const float prev_p[3],
859 const double inittime,
863 float minmax_weights[2])
875 if (bezt->
weight < minmax_weights[0]) {
876 minmax_weights[0] = bezt->
weight;
878 else if (bezt->
weight > minmax_weights[1]) {
879 minmax_weights[1] = bezt->
weight;
894 float minmax_weights[2],
897 const bool add_start_point,
898 const bool add_end_point,
904 int i, tot, old_nbezt = 0;
905 const int add_start_end_points = (add_start_point ? 1 : 0) + (add_end_point ? 1 : 0);
906 float p3d_cur[3], p3d_prev[3], p3d_next[3], h1[3], h2[3];
911 old_nbezt = nu->
pntsu;
943 C, gpl, gps, pt + 1, (stitch) ? p3d_cur : p3d_next, subrect);
945 if (stitch && tot > 2) {
951 if (curnu && old_nbezt) {
956 bezt = &nu->
bezt[old_nbezt - 1];
976 float dt1 = 0.0f, dt2 = 0.0f;
981 prev_bezt = &nu->
bezt[old_nbezt - 2];
983 bezt = &nu->
bezt[old_nbezt - 1];
1041 gtd, bezt, p2, h1, h2, p1, do_gtd, gps->
inittime, dt2, 0.0f, rad_fac, minmax_weights);
1047 else if (add_start_point) {
1064 bezt = &nu->
bezt[old_nbezt];
1066 gtd, bezt, p, h1, h2, p, do_gtd, gps->
inittime, dt, 0.0f, rad_fac, minmax_weights);
1073 prev_bezt = &nu->
bezt[old_nbezt - 1];
1077 for (i = stitch ? 1 : 0, bezt = &nu->
bezt[old_nbezt]; i < tot; i++, pt++, bezt++) {
1080 if (i || old_nbezt) {
1099 prev_bezt ? prev_bezt->
vec[1] : p3d_cur,
1118 if (add_end_point) {
1161 if (!curnu || !*curnu) {
1170 #undef WIDTH_CORR_FAC
1171 #undef BEZT_HANDLE_FAC
1210 const float delta = minmax_weights[0];
1214 if (
IS_EQF(delta, minmax_weights[1])) {
1218 fac = 1.0f / (minmax_weights[1] - delta);
1224 for (
int i = 0; i < nu->pntsu; i++, bezt++) {
1230 for (
int i = 0; i < nu->pntsu; i++, bp++) {
1264 const bool norm_weights,
1265 const float rad_fac,
1266 const bool link_strokes,
1280 float minmax_weights[2] = {1.0f, 0.0f};
1297 subrect_ptr = &subrect;
1317 if (gps->totpoints < 1) {
1320 const bool add_start_point = (link_strokes && !(prev_gps));
1321 const bool add_end_point = (link_strokes && !(gps->next));
1325 bool stitch =
false;
1330 if ((pt1->
x == pt2->
x) && (pt1->
y == pt2->
y)) {
1336 if (!(stitch || link_strokes)) {
1383 if (norm_weights && ((minmax_weights[0] > 0.0f) || (minmax_weights[1] < 1.0f))) {
1413 double base_time, cur_time, prev_time = -1.0;
1423 base_time = cur_time = gps->
inittime;
1424 if (cur_time <= prev_time) {
1429 prev_time = cur_time;
1430 for (i = 0, pt = gps->
points; i < gps->totpoints; i++, pt++) {
1435 if ((i && cur_time <= prev_time) || (cur_time < prev_time)) {
1439 prev_time = cur_time;
1445 }
while ((gps = gps->
next));
1461 if (end_frame <= start_frame) {
1512 "Current Grease Pencil strokes have no valid timing data, most timing options will "
1519 if (!valid_timing &&
1524 if (!link_strokes) {
1547 C, op->
reports, gpd, gpl, mode, norm_weights, rad_fac, link_strokes, >d);
1578 "use_normalize_weights",
1579 "radius_multiplier",
1582 "bevel_resolution")) {
1587 if (
STREQ(prop_id,
"use_timing_data")) {
1593 if (
STREQ(prop_id,
"timing_mode")) {
1599 if (
STR_ELEM(prop_id,
"frame_range",
"start_frame")) {
1604 if (valid_timing &&
STREQ(prop_id,
"use_realtime")) {
1609 if ((!realtime || !valid_timing) &&
STREQ(prop_id,
"end_frame")) {
1615 if (
STREQ(prop_id,
"gap_duration")) {
1620 if (
STREQ(prop_id,
"gap_randomness") && (gap_duration > 0.0f)) {
1625 if (
STREQ(prop_id,
"seed") && (gap_duration > 0.0f) && (gap_randomness > 0.0f)) {
1641 ot->
name =
"Convert Grease Pencil";
1643 ot->
description =
"Convert the active Grease Pencil layer to a new Curve Object";
1659 ot->
srna,
"bevel_depth", 0.0f, 0.0f, 1000.0f,
"Bevel Depth",
"", 0.0f, 10.0f);
1666 "Bevel resolution when depth is non-zero",
1671 "use_normalize_weights",
1674 "Normalize weight (set from stroke width)");
1676 "radius_multiplier",
1681 "Multiplier for the points' radii (set from stroke width)",
1688 "Whether to link strokes with zero-radius sections of curves");
1695 "How to use timing data stored in strokes");
1704 "The duration of evaluation of the path control curve",
1713 "The start frame of the path control curve",
1720 "Whether the path control curve reproduces the drawing in realtime, starting "
1721 "from Start Frame");
1728 "The end frame of the path control curve (if Realtime is not set)",
1739 "Custom Gap mode: (Average) length of gaps, in frames "
1740 "(Note: Realtime value, will be scaled if Realtime is not set)",
1749 "Custom Gap mode: Number of frames that gap lengths can vary",
1758 "Custom Gap mode: Random generator seed",
1768 "Whether the converted Grease Pencil layer has valid timing data (internal use)");
1802 ushort local_view_bits = 0;
1835 ot->
name =
"Generate Grease Pencil Object using image as source";
1836 ot->
idname =
"GPENCIL_OT_image_to_grease_pencil";
1837 ot->
description =
"Generate a Grease Pencil Object using Image as source";
1853 "Size used for grease pencil points",
1862 "Create an inverted image for masking using alpha channel");
typedef float(TangentPoint)[2]
AnimationEvalContext BKE_animsys_eval_context_construct(struct Depsgraph *depsgraph, float eval_time)
bool BKE_collection_object_add(struct Main *bmain, struct Collection *collection, struct Object *ob)
struct ScrArea * CTX_wm_area(const bContext *C)
struct Scene * CTX_data_scene(const bContext *C)
struct ViewLayer * CTX_data_view_layer(const bContext *C)
struct Collection * CTX_data_collection(const bContext *C)
struct Depsgraph * CTX_data_ensure_evaluated_depsgraph(const bContext *C)
struct Object * CTX_data_active_object(const bContext *C)
struct View3D * CTX_wm_view3d(const bContext *C)
struct SpaceLink * CTX_wm_space_data(const bContext *C)
struct ARegion * CTX_wm_region(const bContext *C)
struct Depsgraph * CTX_data_depsgraph_pointer(const bContext *C)
struct SpaceImage * CTX_wm_space_image(const bContext *C)
struct Main * CTX_data_main(const bContext *C)
void BKE_nurb_handles_calc(struct Nurb *nu)
bool BKE_nurb_type_convert(struct Nurb *nu, short type, bool use_handles, const char **r_err_msg)
struct Curve * BKE_curve_add(struct Main *bmain, const char *name, int type)
void BKE_nurb_points_add(struct Nurb *nu, int number)
void BKE_nurb_knot_calc_u(struct Nurb *nu)
void BKE_nurb_bezierPoints_add(struct Nurb *nu, int number)
void BKE_fcurve_handles_recalc(struct FCurve *fcu)
struct bGPDframe * BKE_gpencil_frame_addnew(struct bGPDlayer *gpl, int cframe)
struct Material * BKE_gpencil_object_material_new(struct Main *bmain, struct Object *ob, const char *name, int *r_index)
struct bGPDlayer * BKE_gpencil_layer_active_get(struct bGPdata *gpd)
struct bGPDlayer * BKE_gpencil_layer_addnew(struct bGPdata *gpd, const char *name, bool setactive, bool add_to_header)
bool BKE_gpencil_from_image(struct SpaceImage *sima, struct bGPdata *gpd, struct bGPDframe *gpf, float size, bool mask)
struct bGPDframe * BKE_gpencil_layer_frame_get(struct bGPDlayer *gpl, int cframe, eGP_GetFrame_Mode addnew)
void BKE_gpencil_layer_transform_matrix_get(const struct Depsgraph *depsgraph, struct Object *obact, struct bGPDlayer *gpl, float diff_mat[4][4])
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)
bool BKE_image_has_ibuf(struct Image *ima, struct ImageUser *iuser)
struct Base * BKE_view_layer_base_find(struct ViewLayer *view_layer, struct Object *ob)
General operations, lookup, etc. for materials.
General operations, lookup, etc. for blender objects.
struct Object * BKE_object_add_only_object(struct Main *bmain, int type, const char *name) ATTR_RETURNS_NONNULL
void BKE_reportf(ReportList *reports, eReportType type, const char *format,...) ATTR_PRINTF_FORMAT(3
void BKE_report(ReportList *reports, eReportType type, const char *message)
#define BLI_assert_msg(a, msg)
BLI_INLINE bool BLI_listbase_is_empty(const struct ListBase *lb)
#define LISTBASE_FOREACH(type, var, list)
#define LISTBASE_FOREACH_MUTABLE(type, var, list)
void BLI_addtail(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
MINLINE float min_ff(float a, float b)
MINLINE float interpf(float a, float b, float t)
void mul_v3_m4v3(float r[3], const float M[4][4], const float v[3])
MINLINE float len_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
MINLINE void copy_v3_v3(float r[3], const float a[3])
void interp_v3_v3v3(float r[3], const float a[3], const float b[3], float t)
void BLI_rng_srandom(struct RNG *rng, unsigned int seed) ATTR_NONNULL(1)
void BLI_rng_free(struct RNG *rng) ATTR_NONNULL(1)
struct RNG * BLI_rng_new(unsigned int seed)
float BLI_rng_get_float(struct RNG *rng) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
BLI_INLINE float BLI_rctf_size_x(const struct rctf *rct)
BLI_INLINE float BLI_rctf_size_y(const struct rctf *rct)
typedef double(DMatrix)[4][4]
struct Depsgraph Depsgraph
void DEG_id_tag_update(struct ID *id, int flag)
void DEG_relations_tag_update(struct Main *bmain)
@ FCURVE_EXTRAPOLATE_LINEAR
Object groups, one object can be in many groups at once.
#define GPENCIL_ANY_EDIT_MODE(gpd)
@ GP_MATERIAL_MODE_SQUARE
Object is a sort of wrapper for general info.
void ED_object_base_select(struct Base *base, eObjectSelect_Mode mode)
void ED_view3d_win_to_3d(const struct View3D *v3d, const struct ARegion *region, const float depth_pt[3], const float mval[2], float r_out[3])
void ED_view3d_calc_camera_border(const struct Scene *scene, struct Depsgraph *depsgraph, const struct ARegion *region, const struct View3D *v3d, const struct RegionView3D *rv3d, struct rctf *r_viewborder, bool no_shift)
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint GLsizei width
Read Guarded memory(de)allocation.
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position CLAMP
void UI_view2d_view_to_region_fl(const struct View2D *v2d, float x, float y, float *r_region_x, float *r_region_y) ATTR_NONNULL()
int main(int argc, char *argv[])
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
const Depsgraph * depsgraph
depth_tx normal_tx diffuse_light_tx specular_light_tx volume_light_tx environment_tx ambient_occlusion_tx aov_value_tx in_weight_img image(1, GPU_R32F, Qualifier::WRITE, ImageType::FLOAT_2D_ARRAY, "out_weight_img") .image(3
static int image_to_gpencil_exec(bContext *C, wmOperator *op)
static void gpencil_stroke_to_path(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Curve *cu, rctf *subrect, Nurb **curnu, float minmax_weights[2], const float rad_fac, bool stitch, const bool add_start_point, const bool add_end_point, tGpTimingData *gtd)
static bool gpencil_convert_poll(bContext *C)
struct tGpTimingData tGpTimingData
static void gpencil_stroke_finalize_curve_endpoints(Curve *cu)
static bool gpencil_convert_poll_property(const bContext *UNUSED(C), wmOperator *op, const PropertyRNA *prop)
void GPENCIL_OT_image_to_grease_pencil(wmOperatorType *ot)
static void gpencil_timing_data_add_point(tGpTimingData *gtd, const double stroke_inittime, const float time, const float delta_dist)
static void gpencil_stroke_to_bezier_add_point(tGpTimingData *gtd, BezTriple *bezt, const float p[3], const float h1[3], const float h2[3], const float prev_p[3], const bool do_gtd, const double inittime, const float time, const float width, const float rad_fac, float minmax_weights[2])
static void gpencil_strokepoint_convertcoords(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, bGPDspoint *source_pt, float p3d[3], const rctf *subrect)
static int gpencil_find_end_of_stroke_idx(tGpTimingData *gtd, RNG *rng, const int idx, const int gaps_count, int *gaps_done_count, const float tot_gaps_time, const float delta_time, float *next_delta_time)
static const EnumPropertyItem * rna_GPConvert_mode_items(bContext *UNUSED(C), PointerRNA *ptr, PropertyRNA *UNUSED(prop), bool *UNUSED(r_free))
static void gpencil_stroke_path_animation(bContext *C, ReportList *reports, Curve *cu, tGpTimingData *gtd)
static const EnumPropertyItem prop_gpencil_convert_timingmodes[]
static int gpencil_convert_layer_exec(bContext *C, wmOperator *op)
static const EnumPropertyItem prop_gpencil_convertmodes[]
static void gpencil_stroke_path_animation_preprocess_gaps(tGpTimingData *gtd, RNG *rng, int *gaps_count, float *r_tot_gaps_time)
static bool gpencil_convert_check_has_valid_timing(bContext *C, bGPDlayer *gpl, wmOperator *op)
static void gpencil_layer_to_curve(bContext *C, ReportList *reports, bGPdata *gpd, bGPDlayer *gpl, const int mode, const bool norm_weights, const float rad_fac, const bool link_strokes, tGpTimingData *gtd)
static bool image_to_gpencil_poll(bContext *C)
static const EnumPropertyItem prop_gpencil_convert_timingmodes_restricted[]
void GPENCIL_OT_convert(wmOperatorType *ot)
static void gpencil_stroke_norm_curve_weights(Curve *cu, const float minmax_weights[2])
@ GP_STROKECONVERT_TIMING_LINEAR
@ GP_STROKECONVERT_TIMING_NONE
@ GP_STROKECONVERT_TIMING_CUSTOMGAP
@ GP_STROKECONVERT_TIMING_FULL
static void gpencil_timing_data_set_num(tGpTimingData *gtd, const int num)
static void gpencil_stroke_to_bezier(bContext *C, bGPDlayer *gpl, bGPDstroke *gps, Curve *cu, rctf *subrect, Nurb **curnu, float minmax_weights[2], const float rad_fac, bool stitch, const bool add_start_point, const bool add_end_point, tGpTimingData *gtd)
static void gpencil_stroke_path_animation_add_keyframes(ReportList *reports, PointerRNA ptr, PropertyRNA *prop, Depsgraph *depsgraph, FCurve *fcu, Curve *cu, tGpTimingData *gtd, RNG *rng, const float time_range, const int gaps_count, const float tot_gaps_time)
static void gpencil_convert_set_end_frame(struct Main *UNUSED(main), struct Scene *UNUSED(scene), struct PointerRNA *ptr)
static void gpencil_stroke_to_path_add_point(tGpTimingData *gtd, BPoint *bp, const float p[3], const float prev_p[3], const bool do_gtd, const double inittime, const float time, const float width, const float rad_fac, float minmax_weights[2])
static int gpencil_camera_view_subrect(bContext *C, rctf *subrect)
Object * ED_gpencil_add_object(bContext *C, const float loc[3], ushort local_view_bits)
bAction * ED_id_action_ensure(Main *bmain, ID *id)
bool insert_keyframe_direct(ReportList *reports, PointerRNA ptr, PropertyRNA *prop, FCurve *fcu, const AnimationEvalContext *anim_eval_context, eBezTriple_KeyframeType keytype, struct NlaKeyframingContext *nla_context, eInsertKeyFlags flag)
FCurve * ED_action_fcurve_ensure(struct Main *bmain, struct bAction *act, const char group[], struct PointerRNA *ptr, const char rna_path[], const int array_index)
void(* MEM_freeN)(void *vmemh)
void *(* MEM_callocN)(size_t len, const char *str)
static void area(int d1, int d2, int e1, int e2, float weights[2])
void RNA_id_pointer_create(ID *id, PointerRNA *r_ptr)
const char * RNA_property_identifier(const PropertyRNA *prop)
void RNA_boolean_set(PointerRNA *ptr, const char *name, bool value)
bool RNA_property_is_set(PointerRNA *ptr, PropertyRNA *prop)
void RNA_int_set(PointerRNA *ptr, const char *name, int value)
PropertyRNA * RNA_struct_find_property(PointerRNA *ptr, const char *identifier)
bool RNA_property_boolean_get(PointerRNA *ptr, PropertyRNA *prop)
int RNA_int_get(PointerRNA *ptr, const char *name)
float RNA_float_get(PointerRNA *ptr, const char *name)
bool RNA_boolean_get(PointerRNA *ptr, const char *name)
void RNA_enum_set(PointerRNA *ptr, const char *name, int value)
int RNA_enum_get(PointerRNA *ptr, const char *name)
PropertyRNA * RNA_def_float(StructOrFunctionRNA *cont_, const char *identifier, float default_value, float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
PropertyRNA * RNA_def_boolean(StructOrFunctionRNA *cont_, const char *identifier, bool default_value, const char *ui_name, const char *ui_description)
PropertyRNA * RNA_def_float_distance(StructOrFunctionRNA *cont_, const char *identifier, float default_value, float hardmin, float hardmax, const char *ui_name, const char *ui_description, float softmin, float softmax)
void RNA_def_property_flag(PropertyRNA *prop, PropertyFlag flag)
void RNA_def_property_update_runtime(PropertyRNA *prop, const void *func)
PropertyRNA * RNA_def_int(StructOrFunctionRNA *cont_, const char *identifier, int default_value, int hardmin, int hardmax, const char *ui_name, const char *ui_description, int softmin, int softmax)
void RNA_def_enum_funcs(PropertyRNA *prop, EnumPropertyItemFunc itemfunc)
PropertyRNA * RNA_def_enum(StructOrFunctionRNA *cont_, const char *identifier, const EnumPropertyItem *items, int default_value, const char *ui_name, const char *ui_description)
struct MaterialGPencilStyle * gp_style
int(* invoke)(struct bContext *, struct wmOperator *, const struct wmEvent *) ATTR_WARN_UNUSED_RESULT
bool(* poll)(struct bContext *) ATTR_WARN_UNUSED_RESULT
bool(* poll_property)(const struct bContext *C, struct wmOperator *op, const PropertyRNA *prop) ATTR_WARN_UNUSED_RESULT
int(* exec)(struct bContext *, struct wmOperator *) ATTR_WARN_UNUSED_RESULT
struct ReportList * reports
void WM_event_add_notifier(const bContext *C, uint type, void *reference)
int WM_menu_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))