Differential D2889 Diff 11473 source/blender/makesrna/intern/rna_gpencil.c

Changeset View

Standalone View

source/blender/makesrna/intern/rna_gpencil.c

Show All 20 Lines
*/		*/

/** \file blender/makesrna/intern/rna_gpencil.c		/** \file blender/makesrna/intern/rna_gpencil.c
* \ingroup RNA		* \ingroup RNA
*/		*/

#include <stdlib.h>		#include <stdlib.h>

		#include "BLI_math.h"

		#include "DNA_meshdata_types.h"
#include "DNA_gpencil_types.h"		#include "DNA_gpencil_types.h"
#include "DNA_scene_types.h"		#include "DNA_scene_types.h"
		#include "DNA_brush_types.h"

#include "MEM_guardedalloc.h"		#include "MEM_guardedalloc.h"

#include "BLI_string_utils.h"		#include "BLI_string_utils.h"
#include "BLI_utildefines.h"		#include "BLI_utildefines.h"

#include "BLT_translation.h"		#include "BLT_translation.h"

#include "RNA_access.h"		#include "RNA_access.h"
#include "RNA_define.h"		#include "RNA_define.h"
		#include "RNA_enum_types.h"

#include "rna_internal.h"		#include "rna_internal.h"

#include "WM_types.h"		#include "WM_types.h"
		#include "DNA_meshdata_types.h"
#include "DNA_object_types.h"		#include "DNA_object_types.h"
#include "ED_gpencil.h"		#include "ED_gpencil.h"

/* parent type */		/* parent type */
static const EnumPropertyItem parent_type_items[] = {		static const EnumPropertyItem parent_type_items[] = {
{PAROBJECT, "OBJECT", 0, "Object", "The layer is parented to an object"},		{PAROBJECT, "OBJECT", 0, "Object", "The layer is parented to an object"},
{PARSKEL, "ARMATURE", 0, "Armature", ""},		{PARSKEL, "ARMATURE", 0, "Armature", ""},
{PARBONE, "BONE", 0, "Bone", "The layer is parented to a bone"},		{PARBONE, "BONE", 0, "Bone", "The layer is parented to a bone"},
{0, NULL, 0, NULL, NULL}		{0, NULL, 0, NULL, NULL}
};		};

		#ifndef RNA_RUNTIME
		static EnumPropertyItem rna_enum_gpencil_xraymodes_items[] = {
		{ GP_XRAY_FRONT, "FRONT", 0, "Front", "Draw all strokes in front" },
		{ GP_XRAY_3DSPACE, "3DSPACE", 0, "3DSpace", "Draw strokes relative to other objects in 3D space" },
		{ GP_XRAY_BACK, "BACK", 0, "Back", "Draw all strokes on back" },
		{ 0, NULL, 0, NULL, NULL }
		};

		static EnumPropertyItem rna_enum_gpencil_onion_modes_items[] = {
		{ GP_ONION_MODE_ABSOLUTE, "ABSOLUTE", 0, "Frames", "Frames in absolute range of scene frame number" },
		{ GP_ONION_MODE_RELATIVE, "RELATIVE", 0, "Keyframes", "Frames in relative range of grease pencil keyframes" },
		{ GP_ONION_MODE_SELECTED, "SELECTED", 0, "Selected", "Only Selected Frames" },
		{ 0, NULL, 0, NULL, NULL }
		};
		#endif

#ifdef RNA_RUNTIME		#ifdef RNA_RUNTIME

#include "BLI_math.h"		#include "BLI_math.h"
		#include "BLI_ghash.h"

#include "WM_api.h"		#include "WM_api.h"

		#include "BKE_action.h"
#include "BKE_animsys.h"		#include "BKE_animsys.h"
#include "BKE_gpencil.h"		#include "BKE_gpencil.h"
#include "BKE_action.h"		#include "BKE_icons.h"

		#include "DEG_depsgraph.h"

static void rna_GPencil_update(Main UNUSED(bmain), Scene UNUSED(scene), PointerRNA *UNUSED(ptr))
		static void rna_GPencil_update(Main UNUSED(bmain), Scene UNUSED(scene), PointerRNA *ptr)
{		{
		DEG_id_tag_update(ptr->id.data, OB_RECALC_DATA);
WM_main_add_notifier(NC_GPENCIL \| NA_EDITED, NULL);		WM_main_add_notifier(NC_GPENCIL \| NA_EDITED, NULL);
}		}

static void rna_GPencil_editmode_update(Main UNUSED(bmain), Scene UNUSED(scene), PointerRNA *UNUSED(ptr))		static void rna_GPencil_editmode_update(Main UNUSED(bmain), Scene UNUSED(scene), PointerRNA *ptr)
{		{
		bGPdata gpd = (bGPdata )ptr->id.data;
		DEG_id_tag_update(&gpd->id, OB_RECALC_OB \| OB_RECALC_DATA);

/* Notify all places where GPencil data lives that the editing state is different */		/* Notify all places where GPencil data lives that the editing state is different */
WM_main_add_notifier(NC_GPENCIL \| NA_EDITED, NULL);		WM_main_add_notifier(NC_GPENCIL \| NA_EDITED, NULL);
WM_main_add_notifier(NC_SCENE \| ND_MODE \| NC_MOVIECLIP, NULL);		WM_main_add_notifier(NC_SCENE \| ND_MODE \| NC_MOVIECLIP, NULL);
}		}

static void rna_GPencil_onion_skinning_update(Main bmain, Scene scene, PointerRNA *ptr)		static void UNUSED_FUNCTION(rna_GPencil_onion_skinning_update)(Main bmain, Scene scene, PointerRNA *ptr)
{		{
bGPdata gpd = (bGPdata )ptr->id.data;		bGPdata gpd = (bGPdata )ptr->id.data;
bGPDlayer *gpl;		bGPDlayer *gpl;
bool enabled = false;		bool enabled = false;

/* Ensure that the datablock's onionskinning toggle flag		/* Ensure that the datablock's onionskinning toggle flag
* stays in sync with the status of the actual layers		* stays in sync with the status of the actual layers
*/		*/
for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {		for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {
if (gpl->flag & GP_LAYER_ONIONSKIN) {		if (gpl->onion_flag & GP_LAYER_ONIONSKIN) {
enabled = true;		enabled = true;
}		}
}		}

if (enabled)		if (enabled)
gpd->flag \|= GP_DATA_SHOW_ONIONSKINS;		gpd->flag \|= GP_DATA_SHOW_ONIONSKINS;
else		else
gpd->flag &= ~GP_DATA_SHOW_ONIONSKINS;		gpd->flag &= ~GP_DATA_SHOW_ONIONSKINS;


/* Now do standard updates... */		/* Now do standard updates... */
rna_GPencil_update(bmain, scene, ptr);		rna_GPencil_update(bmain, scene, ptr);
}		}

static void rna_GPencil_stroke_colorname_update(Main bmain, Scene scene, PointerRNA *ptr)
		/* Poll Callback to filter GP Datablocks to only show those for Annotations */
		bool rna_GPencil_datablocks_annotations_poll(PointerRNA *UNUSED(ptr), const PointerRNA value)
{		{
bGPDstroke gps = (bGPDstroke )ptr->data;		bGPdata *gpd = value.data;
gps->flag \|= GP_STROKE_RECALC_COLOR;		return (gpd->flag & GP_DATA_ANNOTATIONS) != 0;
gps->palcolor = NULL;		}

/* Now do standard updates... */		/* Poll Callback to filter GP Datablocks to only show those for GP Objects */
rna_GPencil_update(bmain, scene, ptr);		bool rna_GPencil_datablocks_obdata_poll(PointerRNA *UNUSED(ptr), const PointerRNA value)
		{
		bGPdata *gpd = value.data;
		return (gpd->flag & GP_DATA_ANNOTATIONS) == 0;
}		}


static char rna_GPencilLayer_path(PointerRNA ptr)		static char rna_GPencilLayer_path(PointerRNA ptr)
{		{
bGPDlayer gpl = (bGPDlayer )ptr->data;		bGPDlayer gpl = (bGPDlayer )ptr->data;
char name_esc[sizeof(gpl->info) * 2];		char name_esc[sizeof(gpl->info) * 2];

BLI_strescape(name_esc, gpl->info, sizeof(name_esc));		BLI_strescape(name_esc, gpl->info, sizeof(name_esc));

return BLI_sprintfN("layers[\"%s\"]", name_esc);		return BLI_sprintfN("layers[\"%s\"]", name_esc);
}		}

static int rna_GPencilLayer_active_frame_editable(PointerRNA ptr, const char *UNUSED(r_info))		static int rna_GPencilLayer_active_frame_editable(PointerRNA ptr, const char *UNUSED(r_info))
{		{
bGPDlayer gpl = (bGPDlayer )ptr->data;		bGPDlayer gpl = (bGPDlayer )ptr->data;

/* surely there must be other criteria too... */		/* surely there must be other criteria too... */
if (gpl->flag & GP_LAYER_LOCKED)		if (gpl->flag & GP_LAYER_LOCKED)
return 0;		return 0;
else		else
return PROP_EDITABLE;		return PROP_EDITABLE;
}		}

static void rna_GPencilLayer_line_width_range(PointerRNA ptr, int min, int *max,
int softmin, int softmax)
{
bGPDlayer *gpl = ptr->data;

/* The restrictions on max width here are due to OpenGL on Windows not supporting
* any widths greater than 10 (for driver-drawn) strokes/points.
*
* Although most of our 2D strokes also don't suffer from this restriction,
* it's relatively hard to test for that. So, for now, only volumetric strokes
* get to be larger...
*/

/* From GP v2 this value is used to increase or decrease the thickness of the stroke */
if (gpl->flag & GP_LAYER_VOLUMETRIC) {
*min = -300;
*max = 300;

*softmin = -100;
*softmax = 100;
}
else {
*min = -10;
*max = 10;

*softmin = -10;
*softmax = 10;
}
}

/* set parent */		/* set parent */
static void set_parent(bGPDlayer gpl, Object par, const int type, const char *substr)		static void set_parent(bGPDlayer gpl, Object par, const int type, const char *substr)
{		{
if (type == PAROBJECT) {		if (type == PAROBJECT) {
invert_m4_m4(gpl->inverse, par->obmat);		invert_m4_m4(gpl->inverse, par->obmat);
gpl->parent = par;		gpl->parent = par;
gpl->partype \|= PAROBJECT;		gpl->partype \|= PAROBJECT;
gpl->parsubstr[0] = 0;		gpl->parsubstr[0] = 0;
Show All 23 Lines
{		{
bGPDlayer gpl = (bGPDlayer )ptr->data;		bGPDlayer gpl = (bGPDlayer )ptr->data;
Object par = (Object )value.data;		Object par = (Object )value.data;

if (par != NULL) {		if (par != NULL) {
set_parent(gpl, par, gpl->partype, gpl->parsubstr);		set_parent(gpl, par, gpl->partype, gpl->parsubstr);
}		}
else {		else {
/* keep strokes in the same place, so apply current transformation */
if (gpl->parent != NULL) {
bGPDspoint *pt;
int i;
float diff_mat[4][4];
/* calculate difference matrix */
ED_gpencil_parent_location(gpl, diff_mat);
for (bGPDframe *gpf = gpl->frames.first; gpf; gpf = gpf->next) {
for (bGPDstroke *gps = gpf->strokes.first; gps; gps = gps->next) {
for (i = 0, pt = gps->points; i < gps->totpoints; i++, pt++) {
mul_m4_v3(diff_mat, &pt->x);
}
}
}
}
/* clear parent */		/* clear parent */
gpl->parent = NULL;		gpl->parent = NULL;
}		}
}		}

/* set parent type */		/* set parent type */
static void rna_GPencilLayer_parent_type_set(PointerRNA *ptr, int value)		static void rna_GPencilLayer_parent_type_set(PointerRNA *ptr, int value)
{		{
▲ Show 20 Lines • Show All 73 Lines • ▼ Show 20 Lines	static PointerRNA rna_GPencil_active_layer_get(PointerRNA *ptr)

return rna_pointer_inherit_refine(ptr, NULL, NULL);		return rna_pointer_inherit_refine(ptr, NULL, NULL);
}		}

static void rna_GPencil_active_layer_set(PointerRNA *ptr, PointerRNA value)		static void rna_GPencil_active_layer_set(PointerRNA *ptr, PointerRNA value)
{		{
bGPdata *gpd = ptr->id.data;		bGPdata *gpd = ptr->id.data;

		/* Don't allow setting active layer to NULL if layers exist
		* as this breaks various tools. Tools should be used instead
		* if it's necessary to remove layers
		*/
		if (value.data == NULL) {
		printf("%s: Setting active layer to None is not allowed\n", __func__);
		return;
		}

if (GS(gpd->id.name) == ID_GD) { /* why would this ever be not GD */		if (GS(gpd->id.name) == ID_GD) { /* why would this ever be not GD */
bGPDlayer *gl;		bGPDlayer *gl;

for (gl = gpd->layers.first; gl; gl = gl->next) {		for (gl = gpd->layers.first; gl; gl = gl->next) {
if (gl == value.data) {		if (gl == value.data) {
gl->flag \|= GP_LAYER_ACTIVE;		gl->flag \|= GP_LAYER_ACTIVE;
}		}
else {		else {
Show All 27 Lines	static void rna_GPencil_active_layer_index_range(PointerRNA ptr, int min, int max, int softmin, int *softmax)

*min = 0;		*min = 0;
*max = max_ii(0, BLI_listbase_count(&gpd->layers) - 1);		*max = max_ii(0, BLI_listbase_count(&gpd->layers) - 1);

softmin = min;		softmin = min;
softmax = max;		softmax = max;
}		}

		static const EnumPropertyItem rna_GPencil_active_layer_itemf(bContext C, PointerRNA ptr, PropertyRNA prop, bool *r_free)
		{
		bGPdata gpd = (bGPdata )ptr->id.data;
		bGPDlayer *gpl;
		EnumPropertyItem *item = NULL, item_tmp = {0};
		int totitem = 0;
		int i = 0;

		if (ELEM(NULL, C, gpd)) {
		return DummyRNA_NULL_items;
		}

		/* Existing layers */
		for (gpl = gpd->layers.first, i = 0; gpl; gpl = gpl->next, i++) {
		item_tmp.identifier = gpl->info;
		item_tmp.name = gpl->info;
		item_tmp.value = i;

		item_tmp.icon = BKE_icon_gplayer_color_ensure(gpl);

		RNA_enum_item_add(&item, &totitem, &item_tmp);
		}

		RNA_enum_item_end(&item, &totitem);
		*r_free = true;

		return item;
		}

static void rna_GPencilLayer_info_set(PointerRNA ptr, const char value)		static void rna_GPencilLayer_info_set(PointerRNA ptr, const char value)
{		{
bGPdata *gpd = ptr->id.data;		bGPdata *gpd = ptr->id.data;
bGPDlayer *gpl = ptr->data;		bGPDlayer *gpl = ptr->data;

char oldname[128] = "";		char oldname[128] = "";
BLI_strncpy(oldname, gpl->info, sizeof(oldname));		BLI_strncpy(oldname, gpl->info, sizeof(oldname));

/* copy the new name into the name slot */		/* copy the new name into the name slot */
BLI_strncpy_utf8(gpl->info, value, sizeof(gpl->info));		BLI_strncpy_utf8(gpl->info, value, sizeof(gpl->info));

BLI_uniquename(&gpd->layers, gpl, DATA_("GP_Layer"), '.', offsetof(bGPDlayer, info), sizeof(gpl->info));		BLI_uniquename(&gpd->layers, gpl, DATA_("GP_Layer"), '.', offsetof(bGPDlayer, info), sizeof(gpl->info));

/* now fix animation paths */		/* now fix animation paths */
BKE_animdata_fix_paths_rename_all(&gpd->id, "layers", oldname, gpl->info);		BKE_animdata_fix_paths_rename_all(&gpd->id, "layers", oldname, gpl->info);
}		}

static void rna_GPencil_use_onion_skinning_set(PointerRNA *ptr, const bool value)
{
bGPdata *gpd = ptr->id.data;
bGPDlayer *gpl;

/* set new value */
if (value) {
/* enable on active layer (it's the one that's most likely to be of interest right now) */
gpl = BKE_gpencil_layer_getactive(gpd);
if (gpl) {
gpl->flag \|= GP_LAYER_ONIONSKIN;
}

gpd->flag \|= GP_DATA_SHOW_ONIONSKINS;
}
else {
/* disable on all layers - allowa quickly turning them all off, without having to check */
for (gpl = gpd->layers.first; gpl; gpl = gpl->next) {
gpl->flag &= ~GP_LAYER_ONIONSKIN;
}

gpd->flag &= ~GP_DATA_SHOW_ONIONSKINS;
}
}

static bGPDstroke rna_GPencil_stroke_point_find_stroke(const bGPdata gpd, const bGPDspoint pt, bGPDlayer r_gpl, bGPDframe *r_gpf)		static bGPDstroke rna_GPencil_stroke_point_find_stroke(const bGPdata gpd, const bGPDspoint pt, bGPDlayer r_gpl, bGPDframe *r_gpf)
{		{
bGPDlayer *gpl;		bGPDlayer *gpl;
bGPDstroke *gps;		bGPDstroke *gps;

/* sanity checks */		/* sanity checks */
if (ELEM(NULL, gpd, pt)) {		if (ELEM(NULL, gpd, pt)) {
return NULL;		return NULL;
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines

static void rna_GPencil_stroke_point_add(bGPDstroke *stroke, int count, float pressure, float strength)		static void rna_GPencil_stroke_point_add(bGPDstroke *stroke, int count, float pressure, float strength)
{		{
if (count > 0) {		if (count > 0) {
/* create space at the end of the array for extra points */		/* create space at the end of the array for extra points */
stroke->points = MEM_recallocN_id(stroke->points,		stroke->points = MEM_recallocN_id(stroke->points,
sizeof(bGPDspoint) * (stroke->totpoints + count),		sizeof(bGPDspoint) * (stroke->totpoints + count),
"gp_stroke_points");		"gp_stroke_points");
		stroke->dvert = MEM_recallocN_id(stroke->dvert,
		sizeof(MDeformVert) * (stroke->totpoints + count),
		"gp_stroke_weight");

/* init the pressure and strength values so that old scripts won't need to		/* init the pressure and strength values so that old scripts won't need to
* be modified to give these initial values...		* be modified to give these initial values...
*/		*/
for (int i = 0; i < count; i++) {		for (int i = 0; i < count; i++) {
bGPDspoint *pt = stroke->points + (stroke->totpoints + i);		bGPDspoint *pt = stroke->points + (stroke->totpoints + i);
		MDeformVert *dvert = stroke->dvert + (stroke->totpoints + i);
pt->pressure = pressure;		pt->pressure = pressure;
pt->strength = strength;		pt->strength = strength;

		dvert->totweight = 0;
		dvert->dw = NULL;
}		}

stroke->totpoints += count;		stroke->totpoints += count;
}		}
}		}

static void rna_GPencil_stroke_point_pop(bGPDstroke stroke, ReportList reports, int index)		static void rna_GPencil_stroke_point_pop(bGPDstroke stroke, ReportList reports, int index)
{		{
bGPDspoint *pt_tmp = stroke->points;		bGPDspoint *pt_tmp = stroke->points;
		MDeformVert *pt_dvert = stroke->dvert;

/* python style negative indexing */		/* python style negative indexing */
if (index < 0) {		if (index < 0) {
index += stroke->totpoints;		index += stroke->totpoints;
}		}

if (stroke->totpoints <= index \|\| index < 0) {		if (stroke->totpoints <= index \|\| index < 0) {
BKE_report(reports, RPT_ERROR, "GPencilStrokePoints.pop: index out of range");		BKE_report(reports, RPT_ERROR, "GPencilStrokePoints.pop: index out of range");
return;		return;
}		}

stroke->totpoints--;		stroke->totpoints--;

stroke->points = MEM_callocN(sizeof(bGPDspoint) * stroke->totpoints, "gp_stroke_points");		stroke->points = MEM_callocN(sizeof(bGPDspoint) * stroke->totpoints, "gp_stroke_points");
		stroke->dvert = MEM_callocN(sizeof(MDeformVert) * stroke->totpoints, "gp_stroke_weights");

if (index > 0)		if (index > 0) {
memcpy(stroke->points, pt_tmp, sizeof(bGPDspoint) * index);		memcpy(stroke->points, pt_tmp, sizeof(bGPDspoint) * index);
		/* verify weight data is available */
		if (pt_dvert != NULL) {
		memcpy(stroke->dvert, pt_dvert, sizeof(MDeformVert) * index);
		}
		}

if (index < stroke->totpoints)		if (index < stroke->totpoints) {
memcpy(&stroke->points[index], &pt_tmp[index + 1], sizeof(bGPDspoint) * (stroke->totpoints - index));		memcpy(&stroke->points[index], &pt_tmp[index + 1], sizeof(bGPDspoint) * (stroke->totpoints - index));
		if (pt_dvert != NULL) {
		memcpy(&stroke->dvert[index], &pt_dvert[index + 1], sizeof(MDeformVert) * (stroke->totpoints - index));
		}
		}

/* free temp buffer */		/* free temp buffer */
MEM_freeN(pt_tmp);		MEM_freeN(pt_tmp);
		if (pt_dvert != NULL) {
		MEM_freeN(pt_dvert);
		}

WM_main_add_notifier(NC_GPENCIL \| NA_EDITED, NULL);		WM_main_add_notifier(NC_GPENCIL \| NA_EDITED, NULL);
}		}

static bGPDstroke rna_GPencil_stroke_new(bGPDframe frame, const char *colorname)		static bGPDstroke rna_GPencil_stroke_new(bGPDframe frame)
{		{
bGPDstroke *stroke = MEM_callocN(sizeof(bGPDstroke), "gp_stroke");		bGPDstroke *stroke = MEM_callocN(sizeof(bGPDstroke), "gp_stroke");
if (colorname) {
BLI_strncpy(stroke->colorname, colorname, sizeof(stroke->colorname));
}
stroke->palcolor = NULL;
stroke->flag \|= GP_STROKE_RECALC_COLOR;
BLI_addtail(&frame->strokes, stroke);		BLI_addtail(&frame->strokes, stroke);

return stroke;		return stroke;
}		}

static void rna_GPencil_stroke_remove(bGPDframe frame, ReportList reports, PointerRNA *stroke_ptr)		static void rna_GPencil_stroke_remove(bGPDframe frame, ReportList reports, PointerRNA *stroke_ptr)
{		{
bGPDstroke *stroke = stroke_ptr->data;		bGPDstroke *stroke = stroke_ptr->data;
▲ Show 20 Lines • Show All 113 Lines • ▼ Show 20 Lines

static void rna_GPencil_clear(bGPdata *gpd)		static void rna_GPencil_clear(bGPdata *gpd)
{		{
BKE_gpencil_free_layers(&gpd->layers);		BKE_gpencil_free_layers(&gpd->layers);

WM_main_add_notifier(NC_GPENCIL \| ND_DATA \| NA_EDITED, NULL);		WM_main_add_notifier(NC_GPENCIL \| ND_DATA \| NA_EDITED, NULL);
}		}

/* Palettes */		static void rna_GpencilVertex_groups_begin(CollectionPropertyIterator iter, PointerRNA ptr)
static bGPDpalette rna_GPencil_palette_new(bGPdata gpd, const char *name, bool setactive)
{
bGPDpalette *palette = BKE_gpencil_palette_addnew(gpd, name, setactive != 0);

WM_main_add_notifier(NC_GPENCIL \| ND_DATA \| NA_EDITED, NULL);

return palette;
}

static void rna_GPencil_palette_remove(bGPdata gpd, ReportList reports, PointerRNA *palette_ptr)
{
bGPDpalette *palette = palette_ptr->data;
if (BLI_findindex(&gpd->palettes, palette) == -1) {
BKE_report(reports, RPT_ERROR, "Palette not found in grease pencil data");
return;
}

BKE_gpencil_palette_delete(gpd, palette);
RNA_POINTER_INVALIDATE(palette_ptr);

WM_main_add_notifier(NC_GPENCIL \| ND_DATA \| NA_EDITED, NULL);
}

static PointerRNA rna_GPencil_active_palette_get(PointerRNA *ptr)
{
bGPdata *gpd = ptr->id.data;

if (GS(gpd->id.name) == ID_GD) { /* why would this ever be not GD */
bGPDpalette *palette;

for (palette = gpd->palettes.first; palette; palette = palette->next) {
if (palette->flag & PL_PALETTE_ACTIVE) {
break;
}
}

if (palette) {
return rna_pointer_inherit_refine(ptr, &RNA_GPencilPalette, palette);
}
}

return rna_pointer_inherit_refine(ptr, NULL, NULL);
}

static void rna_GPencil_active_palette_set(PointerRNA *ptr, PointerRNA value)
{
bGPdata *gpd = ptr->id.data;

if (GS(gpd->id.name) == ID_GD) { /* why would this ever be not GD */
bGPDpalette *palette;

for (palette = gpd->palettes.first; palette; palette = palette->next) {
if (palette == value.data) {
palette->flag \|= PL_PALETTE_ACTIVE;
}
else {
palette->flag &= ~PL_PALETTE_ACTIVE;
}
}
/* force color recalc */
BKE_gpencil_palette_change_strokes(gpd);

WM_main_add_notifier(NC_GPENCIL \| NA_EDITED, NULL);
}
}

static int rna_GPencilPalette_index_get(PointerRNA *ptr)
{
bGPdata gpd = (bGPdata )ptr->id.data;
bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);

return BLI_findindex(&gpd->palettes, palette);
}

static void rna_GPencilPalette_index_set(PointerRNA *ptr, int value)
{
bGPdata gpd = (bGPdata )ptr->id.data;
bGPDpalette *palette = BLI_findlink(&gpd->palettes, value);

BKE_gpencil_palette_setactive(gpd, palette);
WM_main_add_notifier(NC_GPENCIL \| ND_DATA \| NA_EDITED, NULL);
}

static void rna_GPencilPalette_index_range(PointerRNA ptr, int min, int max, int softmin, int *softmax)
{
bGPdata gpd = (bGPdata )ptr->id.data;

*min = 0;
*max = max_ii(0, BLI_listbase_count(&gpd->palettes) - 1);

softmin = min;
softmax = max;
}

/* Palette colors */
static bGPDpalettecolor rna_GPencilPalette_color_new(bGPDpalette palette)
{
bGPDpalettecolor *color = BKE_gpencil_palettecolor_addnew(palette, DATA_("Color"), true);

return color;
}

static void rna_GPencilPalette_color_remove(bGPDpalette palette, ReportList reports, PointerRNA *color_ptr)
{
bGPDpalettecolor *color = color_ptr->data;

if (BLI_findindex(&palette->colors, color) == -1) {
BKE_reportf(reports, RPT_ERROR, "Palette '%s' does not contain color given", palette->info + 2);
return;
}

BKE_gpencil_palettecolor_delete(palette, color);
RNA_POINTER_INVALIDATE(color_ptr);

WM_main_add_notifier(NC_GPENCIL \| ND_DATA \| NA_EDITED, NULL);
}

static PointerRNA rna_GPencilPalette_active_color_get(PointerRNA *ptr)
{
bGPDpalette palette = (bGPDpalette )ptr->data;
bGPDpalettecolor *color;

for (color = palette->colors.first; color; color = color->next) {
if (color->flag & PC_COLOR_ACTIVE) {
break;
}
}

if (color) {
return rna_pointer_inherit_refine(ptr, &RNA_GPencilPaletteColor, color);
}

return rna_pointer_inherit_refine(ptr, NULL, NULL);
}

static void rna_GPencilPalette_active_color_set(PointerRNA *ptr, PointerRNA value)
{
bGPDpalette palette = (bGPDpalette )ptr->data;
bGPDpalettecolor *color = value.data;

BKE_gpencil_palettecolor_setactive(palette, color);
}

static void rna_GPencilPalette_info_set(PointerRNA ptr, const char value)
{
bGPdata *gpd = ptr->id.data;
bGPDpalette *palette = ptr->data;

char oldname[64] = "";
BLI_strncpy(oldname, palette->info, sizeof(oldname));

/* copy the new name into the name slot */
BLI_strncpy_utf8(palette->info, value, sizeof(palette->info));

BLI_uniquename(&gpd->palettes, palette, DATA_("GP_Palette"), '.', offsetof(bGPDpalette, info),
sizeof(palette->info));
/* now fix animation paths */
BKE_animdata_fix_paths_rename_all(&gpd->id, "palettes", oldname, palette->info);
}

static char rna_GPencilPalette_path(PointerRNA ptr)
{
bGPDpalette *palette = ptr->data;
char name_esc[sizeof(palette->info) * 2];

BLI_strescape(name_esc, palette->info, sizeof(name_esc));

return BLI_sprintfN("palettes[\"%s\"]", name_esc);
}

static char rna_GPencilPalette_color_path(PointerRNA ptr)
{
bGPdata *gpd = ptr->id.data;
bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);
bGPDpalettecolor *palcolor = ptr->data;

char name_palette[sizeof(palette->info) * 2];
char name_color[sizeof(palcolor->info) * 2];

BLI_strescape(name_palette, palette->info, sizeof(name_palette));
BLI_strescape(name_color, palcolor->info, sizeof(name_color));

return BLI_sprintfN("palettes[\"%s\"].colors[\"%s\"]", name_palette, name_color);
}

static void rna_GPencilPaletteColor_info_set(PointerRNA ptr, const char value)
{
bGPdata *gpd = ptr->id.data;
bGPDpalette *palette = BKE_gpencil_palette_getactive(gpd);
bGPDpalettecolor *palcolor = ptr->data;

char oldname[64] = "";
BLI_strncpy(oldname, palcolor->info, sizeof(oldname));

/* copy the new name into the name slot */
BLI_strncpy_utf8(palcolor->info, value, sizeof(palcolor->info));
BLI_uniquename(&palette->colors, palcolor, DATA_("Color"), '.', offsetof(bGPDpalettecolor, info),
sizeof(palcolor->info));

/* rename all strokes */
BKE_gpencil_palettecolor_changename(gpd, oldname, palcolor->info);

/* now fix animation paths */
BKE_animdata_fix_paths_rename_all(&gpd->id, "colors", oldname, palcolor->info);
}

static void rna_GPencilStrokeColor_info_set(PointerRNA ptr, const char value)
{		{
bGPDstroke *gps = ptr->data;		bGPDstroke *gps = ptr->data;

/* copy the new name into the name slot */		if (gps->dvert) {
BLI_strncpy_utf8(gps->colorname, value, sizeof(gps->colorname));		MDeformVert *dvert = gps->dvert;
}

		rna_iterator_array_begin(iter, (void *)dvert->dw, sizeof(MDeformWeight), dvert->totweight, 0, NULL);
static bool rna_GPencilPaletteColor_is_stroke_visible_get(PointerRNA *ptr)
{
bGPDpalettecolor pcolor = (bGPDpalettecolor )ptr->data;
return (pcolor->color[3] > GPENCIL_ALPHA_OPACITY_THRESH);
}

static bool rna_GPencilPaletteColor_is_fill_visible_get(PointerRNA *ptr)
{
bGPDpalettecolor pcolor = (bGPDpalettecolor )ptr->data;
return (pcolor->fill[3] > GPENCIL_ALPHA_OPACITY_THRESH);
}		}
		else
static int rna_GPencilPaletteColor_index_get(PointerRNA *ptr)		rna_iterator_array_begin(iter, NULL, 0, 0, 0, NULL);
{
bGPDpalette palette = (bGPDpalette )ptr->data;
bGPDpalettecolor *pcolor = BKE_gpencil_palettecolor_getactive(palette);

return BLI_findindex(&palette->colors, pcolor);
}

static void rna_GPencilPaletteColor_index_set(PointerRNA *ptr, int value)
{
bGPDpalette palette = (bGPDpalette )ptr->data;
bGPDpalettecolor *pcolor = BLI_findlink(&palette->colors, value);
BKE_gpencil_palettecolor_setactive(palette, pcolor);
}

static void rna_GPencilPaletteColor_index_range(PointerRNA ptr, int min, int max, int softmin, int *softmax)
{
bGPDpalette palette = (bGPDpalette )ptr->data;

*min = 0;
*max = max_ii(0, BLI_listbase_count(&palette->colors) - 1);

softmin = min;
softmax = max;
}		}

#else		#else

static void rna_def_gpencil_stroke_point(BlenderRNA *brna)		static void rna_def_gpencil_stroke_point(BlenderRNA *brna)
{		{
StructRNA *srna;		StructRNA *srna;
PropertyRNA *prop;		PropertyRNA *prop;

srna = RNA_def_struct(brna, "GPencilStrokePoint", NULL);		srna = RNA_def_struct(brna, "GPencilStrokePoint", NULL);
Show All 13 Lines	static void rna_def_gpencil_stroke_point(BlenderRNA *brna)
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

prop = RNA_def_property(srna, "strength", PROP_FLOAT, PROP_NONE);		prop = RNA_def_property(srna, "strength", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, NULL, "strength");		RNA_def_property_float_sdna(prop, NULL, "strength");
RNA_def_property_range(prop, 0.0f, 1.0f);		RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(prop, "Strength", "Color intensity (alpha factor)");		RNA_def_property_ui_text(prop, "Strength", "Color intensity (alpha factor)");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

		prop = RNA_def_property(srna, "uv_factor", PROP_FLOAT, PROP_NONE);
		RNA_def_property_float_sdna(prop, NULL, "uv_fac");
		RNA_def_property_range(prop, 0.0f, 1.0f);
		RNA_def_property_ui_text(prop, "UV Factor", "Internal UV factor");
		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

		prop = RNA_def_property(srna, "uv_rotation", PROP_FLOAT, PROP_ANGLE);
		RNA_def_property_float_sdna(prop, NULL, "uv_rot");
		RNA_def_property_range(prop, 0.0f, M_PI * 2);
		RNA_def_property_ui_text(prop, "UV Rotation", "Internal UV factor for dot mode");
		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);		prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SPOINT_SELECT);		RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_SPOINT_SELECT);
RNA_def_property_boolean_funcs(prop, NULL, "rna_GPencil_stroke_point_select_set");		RNA_def_property_boolean_funcs(prop, NULL, "rna_GPencil_stroke_point_select_set");
RNA_def_property_ui_text(prop, "Select", "Point is selected for viewport editing");		RNA_def_property_ui_text(prop, "Select", "Point is selected for viewport editing");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

}		}

static void rna_def_gpencil_stroke_points_api(BlenderRNA brna, PropertyRNA cprop)		static void rna_def_gpencil_stroke_points_api(BlenderRNA brna, PropertyRNA cprop)
{		{
StructRNA *srna;		StructRNA *srna;
FunctionRNA *func;		FunctionRNA *func;

RNA_def_property_srna(cprop, "GPencilStrokePoints");		RNA_def_property_srna(cprop, "GPencilStrokePoints");
Show All 16 Lines
/* This information is read only and it can be used by add-ons */		/* This information is read only and it can be used by add-ons */
static void rna_def_gpencil_triangle(BlenderRNA *brna)		static void rna_def_gpencil_triangle(BlenderRNA *brna)
{		{
StructRNA *srna;		StructRNA *srna;
PropertyRNA *prop;		PropertyRNA *prop;

srna = RNA_def_struct(brna, "GPencilTriangle", NULL);		srna = RNA_def_struct(brna, "GPencilTriangle", NULL);
RNA_def_struct_sdna(srna, "bGPDtriangle");		RNA_def_struct_sdna(srna, "bGPDtriangle");
RNA_def_struct_ui_text(srna, "Triangle", "Triangulation data for HQ fill");		RNA_def_struct_ui_text(srna, "Triangle", "Triangulation data for Grease Pencil fills");

/* point v1 */		/* point v1 */
prop = RNA_def_property(srna, "v1", PROP_INT, PROP_NONE);		prop = RNA_def_property(srna, "v1", PROP_INT, PROP_NONE);
RNA_def_property_int_sdna(prop, NULL, "verts[0]");		RNA_def_property_int_sdna(prop, NULL, "verts[0]");
RNA_def_property_ui_text(prop, "v1", "First triangle vertex index");		RNA_def_property_ui_text(prop, "v1", "First triangle vertex index");
RNA_def_property_clear_flag(prop, PROP_EDITABLE);		RNA_def_property_clear_flag(prop, PROP_EDITABLE);

/* point v2 */		/* point v2 */
prop = RNA_def_property(srna, "v2", PROP_INT, PROP_NONE);		prop = RNA_def_property(srna, "v2", PROP_INT, PROP_NONE);
RNA_def_property_int_sdna(prop, NULL, "verts[1]");		RNA_def_property_int_sdna(prop, NULL, "verts[1]");
RNA_def_property_ui_text(prop, "v2", "Second triangle vertex index");		RNA_def_property_ui_text(prop, "v2", "Second triangle vertex index");
RNA_def_property_clear_flag(prop, PROP_EDITABLE);		RNA_def_property_clear_flag(prop, PROP_EDITABLE);

/* point v3 */		/* point v3 */
prop = RNA_def_property(srna, "v3", PROP_INT, PROP_NONE);		prop = RNA_def_property(srna, "v3", PROP_INT, PROP_NONE);
RNA_def_property_int_sdna(prop, NULL, "verts[2]");		RNA_def_property_int_sdna(prop, NULL, "verts[2]");
RNA_def_property_ui_text(prop, "v3", "Third triangle vertex index");		RNA_def_property_ui_text(prop, "v3", "Third triangle vertex index");
RNA_def_property_clear_flag(prop, PROP_EDITABLE);		RNA_def_property_clear_flag(prop, PROP_EDITABLE);

		/* texture coord for point v1 */
		prop = RNA_def_property(srna, "uv1", PROP_FLOAT, PROP_COORDS);
		RNA_def_property_float_sdna(prop, NULL, "uv[0]");
		RNA_def_property_array(prop, 2);
		RNA_def_property_ui_text(prop, "uv1", "First triangle vertex texture coordinates");
		RNA_def_property_clear_flag(prop, PROP_EDITABLE);

		/* texture coord for point v2 */
		prop = RNA_def_property(srna, "uv2", PROP_FLOAT, PROP_COORDS);
		RNA_def_property_float_sdna(prop, NULL, "uv[1]");
		RNA_def_property_array(prop, 2);
		RNA_def_property_ui_text(prop, "uv2", "Second triangle vertex texture coordinates");
		RNA_def_property_clear_flag(prop, PROP_EDITABLE);

		/* texture coord for point v3 */
		prop = RNA_def_property(srna, "uv3", PROP_FLOAT, PROP_COORDS);
		RNA_def_property_float_sdna(prop, NULL, "uv[2]");
		RNA_def_property_array(prop, 2);
		RNA_def_property_ui_text(prop, "uv3", "Third triangle vertex texture coordinates");
		RNA_def_property_clear_flag(prop, PROP_EDITABLE);
		}

		static void rna_def_gpencil_mvert_group(BlenderRNA *brna)
		{
		StructRNA *srna;
		PropertyRNA *prop;

		srna = RNA_def_struct(brna, "GpencilVertexGroupElement", NULL);
		RNA_def_struct_sdna(srna, "MDeformWeight");
		RNA_def_struct_ui_text(srna, "Vertex Group Element", "Weight value of a vertex in a vertex group");
		RNA_def_struct_ui_icon(srna, ICON_GROUP_VERTEX);

		/* we can't point to actual group, it is in the object and so
		* there is no unique group to point to, hence the index */
		prop = RNA_def_property(srna, "group", PROP_INT, PROP_UNSIGNED);
		RNA_def_property_int_sdna(prop, NULL, "def_nr");
		RNA_def_property_clear_flag(prop, PROP_EDITABLE);
		RNA_def_property_ui_text(prop, "Group Index", "");
		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

		prop = RNA_def_property(srna, "weight", PROP_FLOAT, PROP_NONE);
		RNA_def_property_range(prop, 0.0f, 1.0f);
		RNA_def_property_ui_text(prop, "Weight", "Vertex Weight");
		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");
}		}

static void rna_def_gpencil_stroke(BlenderRNA *brna)		static void rna_def_gpencil_stroke(BlenderRNA *brna)
{		{
StructRNA *srna;		StructRNA *srna;
PropertyRNA *prop;		PropertyRNA *prop;

static const EnumPropertyItem stroke_draw_mode_items[] = {		static const EnumPropertyItem stroke_draw_mode_items[] = {
Show All 10 Lines	static void rna_def_gpencil_stroke(BlenderRNA *brna)

/* Points */		/* Points */
prop = RNA_def_property(srna, "points", PROP_COLLECTION, PROP_NONE);		prop = RNA_def_property(srna, "points", PROP_COLLECTION, PROP_NONE);
RNA_def_property_collection_sdna(prop, NULL, "points", "totpoints");		RNA_def_property_collection_sdna(prop, NULL, "points", "totpoints");
RNA_def_property_struct_type(prop, "GPencilStrokePoint");		RNA_def_property_struct_type(prop, "GPencilStrokePoint");
RNA_def_property_ui_text(prop, "Stroke Points", "Stroke data points");		RNA_def_property_ui_text(prop, "Stroke Points", "Stroke data points");
rna_def_gpencil_stroke_points_api(brna, prop);		rna_def_gpencil_stroke_points_api(brna, prop);

		/* vertex groups */
		prop = RNA_def_property(srna, "groups", PROP_COLLECTION, PROP_NONE);
		RNA_def_property_collection_funcs(prop, "rna_GpencilVertex_groups_begin", "rna_iterator_array_next",
		"rna_iterator_array_end", "rna_iterator_array_get", NULL, NULL, NULL, NULL);
		RNA_def_property_struct_type(prop, "GpencilVertexGroupElement");
		RNA_def_property_ui_text(prop, "Groups", "Weights for the vertex groups this vertex is member of");

/* Triangles */		/* Triangles */
prop = RNA_def_property(srna, "triangles", PROP_COLLECTION, PROP_NONE);		prop = RNA_def_property(srna, "triangles", PROP_COLLECTION, PROP_NONE);
RNA_def_property_collection_sdna(prop, NULL, "triangles", "tot_triangles");		RNA_def_property_collection_sdna(prop, NULL, "triangles", "tot_triangles");
RNA_def_property_struct_type(prop, "GPencilTriangle");		RNA_def_property_struct_type(prop, "GPencilTriangle");
RNA_def_property_ui_text(prop, "Triangles", "Triangulation data for HQ fill");		RNA_def_property_ui_text(prop, "Triangles", "Triangulation data for HQ fill");

/* Color */		/* Material Index */
prop = RNA_def_property(srna, "color", PROP_POINTER, PROP_NONE);		prop = RNA_def_property(srna, "material_index", PROP_INT, PROP_NONE);
RNA_def_property_struct_type(prop, "GPencilPaletteColor");		RNA_def_property_int_sdna(prop, NULL, "mat_nr");
RNA_def_property_pointer_sdna(prop, NULL, "palcolor");		RNA_def_property_ui_text(prop, "Material Index", "Index of material used in this stroke");
RNA_def_property_ui_text(prop, "Palette Color", "Color from palette used in Stroke");		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");
RNA_def_property_update(prop, 0, "rna_GPencil_update");

/* Settings */		/* Settings */
prop = RNA_def_property(srna, "draw_mode", PROP_ENUM, PROP_NONE);		prop = RNA_def_property(srna, "draw_mode", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");		RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
RNA_def_property_enum_items(prop, stroke_draw_mode_items);		RNA_def_property_enum_items(prop, stroke_draw_mode_items);
RNA_def_property_ui_text(prop, "Draw Mode", "");		RNA_def_property_ui_text(prop, "Draw Mode", "Coordinate space that stroke is in");
RNA_def_property_update(prop, 0, "rna_GPencil_update");		RNA_def_property_update(prop, 0, "rna_GPencil_update");

prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);		prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_STROKE_SELECT);		RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_STROKE_SELECT);
RNA_def_property_boolean_funcs(prop, NULL, "rna_GPencil_stroke_select_set");		RNA_def_property_boolean_funcs(prop, NULL, "rna_GPencil_stroke_select_set");
RNA_def_property_ui_text(prop, "Select", "Stroke is selected for viewport editing");		RNA_def_property_ui_text(prop, "Select", "Stroke is selected for viewport editing");
RNA_def_property_update(prop, 0, "rna_GPencil_update");		RNA_def_property_update(prop, 0, "rna_GPencil_update");

/* Color Name */
prop = RNA_def_property(srna, "colorname", PROP_STRING, PROP_NONE);
RNA_def_property_string_funcs(prop, NULL, NULL, "rna_GPencilStrokeColor_info_set");
RNA_def_property_ui_text(prop, "Color Name", "Palette color name");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_stroke_colorname_update");

/* Cyclic: Draw a line from end to start point */		/* Cyclic: Draw a line from end to start point */
prop = RNA_def_property(srna, "draw_cyclic", PROP_BOOLEAN, PROP_NONE);		prop = RNA_def_property(srna, "draw_cyclic", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_STROKE_CYCLIC);		RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_STROKE_CYCLIC);
RNA_def_property_ui_text(prop, "Cyclic", "Enable cyclic drawing, closing the stroke");		RNA_def_property_ui_text(prop, "Cyclic", "Enable cyclic drawing, closing the stroke");
RNA_def_property_update(prop, 0, "rna_GPencil_update");		RNA_def_property_update(prop, 0, "rna_GPencil_update");

		/* No fill: The stroke never must fill area and must use fill color as stroke color (this is a special flag for fill brush) */
		prop = RNA_def_property(srna, "is_nofill_stroke", PROP_BOOLEAN, PROP_NONE);
		RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_STROKE_NOFILL);
		RNA_def_property_clear_flag(prop, PROP_EDITABLE);
		RNA_def_property_ui_text(prop, "No Fill", "Special stroke to use as boundary for filling areas");
		RNA_def_property_update(prop, 0, "rna_GPencil_update");

/* Line Thickness */		/* Line Thickness */
prop = RNA_def_property(srna, "line_width", PROP_INT, PROP_PIXEL);		prop = RNA_def_property(srna, "line_width", PROP_INT, PROP_PIXEL);
RNA_def_property_int_sdna(prop, NULL, "thickness");		RNA_def_property_int_sdna(prop, NULL, "thickness");
RNA_def_property_range(prop, 1, 300);		RNA_def_property_range(prop, 1, 1000);
RNA_def_property_ui_range(prop, 1, 10, 1, 0);		RNA_def_property_ui_range(prop, 1, 10, 1, 0);
RNA_def_property_ui_text(prop, "Thickness", "Thickness of stroke (in pixels)");		RNA_def_property_ui_text(prop, "Thickness", "Thickness of stroke (in pixels)");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

}		}

static void rna_def_gpencil_strokes_api(BlenderRNA brna, PropertyRNA cprop)		static void rna_def_gpencil_strokes_api(BlenderRNA brna, PropertyRNA cprop)
{		{
StructRNA *srna;		StructRNA *srna;

FunctionRNA *func;		FunctionRNA *func;
PropertyRNA *parm;		PropertyRNA *parm;

RNA_def_property_srna(cprop, "GPencilStrokes");		RNA_def_property_srna(cprop, "GPencilStrokes");
srna = RNA_def_struct(brna, "GPencilStrokes", NULL);		srna = RNA_def_struct(brna, "GPencilStrokes", NULL);
RNA_def_struct_sdna(srna, "bGPDframe");		RNA_def_struct_sdna(srna, "bGPDframe");
RNA_def_struct_ui_text(srna, "Grease Pencil Frames", "Collection of grease pencil stroke");		RNA_def_struct_ui_text(srna, "Grease Pencil Frames", "Collection of grease pencil stroke");

func = RNA_def_function(srna, "new", "rna_GPencil_stroke_new");		func = RNA_def_function(srna, "new", "rna_GPencil_stroke_new");
RNA_def_function_ui_description(func, "Add a new grease pencil stroke");		RNA_def_function_ui_description(func, "Add a new grease pencil stroke");
parm = RNA_def_string(func, "colorname", 0, MAX_NAME, "Color", "Name of the color");
parm = RNA_def_pointer(func, "stroke", "GPencilStroke", "", "The newly created stroke");		parm = RNA_def_pointer(func, "stroke", "GPencilStroke", "", "The newly created stroke");
RNA_def_function_return(func, parm);		RNA_def_function_return(func, parm);

func = RNA_def_function(srna, "remove", "rna_GPencil_stroke_remove");		func = RNA_def_function(srna, "remove", "rna_GPencil_stroke_remove");
RNA_def_function_ui_description(func, "Remove a grease pencil stroke");		RNA_def_function_ui_description(func, "Remove a grease pencil stroke");
RNA_def_function_flag(func, FUNC_USE_REPORTS);		RNA_def_function_flag(func, FUNC_USE_REPORTS);
parm = RNA_def_pointer(func, "stroke", "GPencilStroke", "Stroke", "The stroke to remove");		parm = RNA_def_pointer(func, "stroke", "GPencilStroke", "Stroke", "The stroke to remove");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED \| PARM_RNAPTR);		RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED \| PARM_RNAPTR);
▲ Show 20 Lines • Show All 104 Lines • ▼ Show 20 Lines	static void rna_def_gpencil_layer(BlenderRNA *brna)

/* Active Frame */		/* Active Frame */
prop = RNA_def_property(srna, "active_frame", PROP_POINTER, PROP_NONE);		prop = RNA_def_property(srna, "active_frame", PROP_POINTER, PROP_NONE);
RNA_def_property_pointer_sdna(prop, NULL, "actframe");		RNA_def_property_pointer_sdna(prop, NULL, "actframe");
RNA_def_property_ui_text(prop, "Active Frame", "Frame currently being displayed for this layer");		RNA_def_property_ui_text(prop, "Active Frame", "Frame currently being displayed for this layer");
RNA_def_property_editable_func(prop, "rna_GPencilLayer_active_frame_editable");		RNA_def_property_editable_func(prop, "rna_GPencilLayer_active_frame_editable");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, NULL);		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, NULL);

/* Draw Style */
// TODO: replace these with a "draw type" combo (i.e. strokes only, filled strokes, strokes + fills, volumetric)?
prop = RNA_def_property(srna, "use_volumetric_strokes", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_VOLUMETRIC);
RNA_def_property_ui_text(prop, "Volumetric Strokes",
"Draw strokes as a series of circular blobs, resulting in a volumetric effect");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

		/* Layer Opacity */
prop = RNA_def_property(srna, "opacity", PROP_FLOAT, PROP_NONE);		prop = RNA_def_property(srna, "opacity", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, NULL, "opacity");		RNA_def_property_float_sdna(prop, NULL, "opacity");
RNA_def_property_range(prop, 0.0, 1.0f);		RNA_def_property_range(prop, 0.0, 1.0f);
RNA_def_property_ui_text(prop, "Opacity", "Layer Opacity");		RNA_def_property_ui_text(prop, "Opacity", "Layer Opacity");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");


		/* Stroke Drawing Color (Annotations) */
		prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
		RNA_def_property_array(prop, 3);
		RNA_def_property_range(prop, 0.0f, 1.0f);
		RNA_def_property_ui_text(prop, "Color", "Color for all strokes in this layer");
		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

		/* Line Thickness (Annotations) */
		prop = RNA_def_property(srna, "thickness", PROP_INT, PROP_PIXEL);
		RNA_def_property_int_sdna(prop, NULL, "thickness");
		RNA_def_property_range(prop, 1, 10);
		RNA_def_property_ui_text(prop, "Thickness", "Thickness of annotation strokes");
		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");


/* Tint Color */		/* Tint Color */
prop = RNA_def_property(srna, "tint_color", PROP_FLOAT, PROP_COLOR_GAMMA);		prop = RNA_def_property(srna, "tint_color", PROP_FLOAT, PROP_COLOR_GAMMA);
RNA_def_property_float_sdna(prop, NULL, "tintcolor");		RNA_def_property_float_sdna(prop, NULL, "tintcolor");
RNA_def_property_array(prop, 3);		RNA_def_property_array(prop, 3);
RNA_def_property_range(prop, 0.0f, 1.0f);		RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(prop, "Tint Color", "Color for tinting stroke colors");		RNA_def_property_ui_text(prop, "Tint Color", "Color for tinting stroke colors");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

/* Tint factor */		/* Tint factor */
prop = RNA_def_property(srna, "tint_factor", PROP_FLOAT, PROP_NONE);		prop = RNA_def_property(srna, "tint_factor", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, NULL, "tintcolor[3]");		RNA_def_property_float_sdna(prop, NULL, "tintcolor[3]");
RNA_def_property_range(prop, 0.0, 1.0f);		RNA_def_property_range(prop, 0.0, 1.0f);
RNA_def_property_ui_text(prop, "Tint Factor", "Factor of tinting color");		RNA_def_property_ui_text(prop, "Tint Factor", "Factor of tinting color");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

/* Line Thickness change */		/* Line Thickness Change */
prop = RNA_def_property(srna, "line_change", PROP_INT, PROP_PIXEL);		prop = RNA_def_property(srna, "line_change", PROP_INT, PROP_PIXEL);
RNA_def_property_int_sdna(prop, NULL, "thickness");		RNA_def_property_int_sdna(prop, NULL, "line_change");
//RNA_def_property_range(prop, 1, 10); /* 10 px limit comes from Windows OpenGL limits for natively-drawn strokes */		RNA_def_property_range(prop, -300, 300);
RNA_def_property_int_funcs(prop, NULL, NULL, "rna_GPencilLayer_line_width_range");		RNA_def_property_ui_range(prop, -100, 100, 1.0, 1);
RNA_def_property_ui_text(prop, "Thickness", "Thickness change to apply to current strokes (in pixels)");		RNA_def_property_ui_text(prop, "Thickness Change", "Thickness change to apply to current strokes (in pixels)");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");


/* Onion-Skinning */		/* Onion-Skinning */
prop = RNA_def_property(srna, "use_onion_skinning", PROP_BOOLEAN, PROP_NONE);		prop = RNA_def_property(srna, "use_onion_skinning", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_ONIONSKIN);		RNA_def_property_boolean_sdna(prop, NULL, "onion_flag", GP_LAYER_ONIONSKIN);
RNA_def_property_ui_text(prop, "Onion Skinning", "Ghost frames on either side of frame");		RNA_def_property_ui_text(prop, "Onion Skinning", "Ghost frames on either side of frame");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_onion_skinning_update");

prop = RNA_def_property(srna, "ghost_before_range", PROP_INT, PROP_NONE);
RNA_def_property_int_sdna(prop, NULL, "gstep");
RNA_def_property_range(prop, -1, 120);
RNA_def_property_ui_text(prop, "Frames Before",
"Maximum number of frames to show before current frame "
"(0 = show only the previous sketch, -1 = don't show any frames before current)");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

prop = RNA_def_property(srna, "ghost_after_range", PROP_INT, PROP_NONE);
RNA_def_property_int_sdna(prop, NULL, "gstep_next");
RNA_def_property_range(prop, -1, 120);
RNA_def_property_ui_text(prop, "Frames After",
"Maximum number of frames to show after current frame "
"(0 = show only the next sketch, -1 = don't show any frames after current)");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

prop = RNA_def_property(srna, "use_ghost_custom_colors", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_GHOST_PREVCOL \| GP_LAYER_GHOST_NEXTCOL);
RNA_def_property_ui_text(prop, "Use Custom Ghost Colors", "Use custom colors for ghost frames");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

prop = RNA_def_property(srna, "before_color", PROP_FLOAT, PROP_COLOR_GAMMA);
RNA_def_property_float_sdna(prop, NULL, "gcolor_prev");
RNA_def_property_array(prop, 3);
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(prop, "Before Color", "Base color for ghosts before the active frame");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

prop = RNA_def_property(srna, "after_color", PROP_FLOAT, PROP_COLOR_GAMMA);
RNA_def_property_float_sdna(prop, NULL, "gcolor_next");
RNA_def_property_array(prop, 3);
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(prop, "After Color", "Base color for ghosts after the active frame");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

prop = RNA_def_property(srna, "use_ghosts_always", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_GHOST_ALWAYS);
RNA_def_property_ui_text(prop, "Always Show Ghosts",
"Ghosts are shown in renders and animation playback. Useful for special effects (e.g. motion blur)");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");


/* Flags */		/* Flags */
prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);		prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_HIDE);		RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_HIDE);
RNA_def_property_ui_icon(prop, ICON_HIDE_OFF, 1);		RNA_def_property_ui_icon(prop, ICON_HIDE_OFF, 1);
RNA_def_property_ui_text(prop, "Hide", "Set layer Visibility");		RNA_def_property_ui_text(prop, "Hide", "Set layer Visibility");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

prop = RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);		prop = RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
Show All 12 Lines	static void rna_def_gpencil_layer(BlenderRNA *brna)
prop = RNA_def_property(srna, "unlock_color", PROP_BOOLEAN, PROP_NONE);		prop = RNA_def_property(srna, "unlock_color", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_UNLOCK_COLOR);		RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_UNLOCK_COLOR);
RNA_def_property_ui_icon(prop, ICON_RESTRICT_COLOR_OFF, 1);		RNA_def_property_ui_icon(prop, ICON_RESTRICT_COLOR_OFF, 1);
RNA_def_property_ui_text(prop, "Unlock Color",		RNA_def_property_ui_text(prop, "Unlock Color",
"Unprotect selected colors from further editing and/or frame changes");		"Unprotect selected colors from further editing and/or frame changes");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, NULL);		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, NULL);


/* expose as layers.active */		/* exposed as layers.active */
#if 0		#if 0
prop = RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);		prop = RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_ACTIVE);		RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_ACTIVE);
RNA_def_property_boolean_funcs(prop, NULL, "rna_GPencilLayer_active_set");		RNA_def_property_boolean_funcs(prop, NULL, "rna_GPencilLayer_active_set");
RNA_def_property_ui_text(prop, "Active", "Set active layer for editing");		RNA_def_property_ui_text(prop, "Active", "Set active layer for editing");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA \| NA_SELECTED, NULL);		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA \| NA_SELECTED, NULL);
#endif		#endif

prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);		prop = RNA_def_property(srna, "select", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_SELECT);		RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_SELECT);
RNA_def_property_ui_text(prop, "Select", "Layer is selected for editing in the Dope Sheet");		RNA_def_property_ui_text(prop, "Select", "Layer is selected for editing in the Dope Sheet");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA \| NA_SELECTED, "rna_GPencil_update");		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA \| NA_SELECTED, "rna_GPencil_update");

/* XXX keep this option? */
prop = RNA_def_property(srna, "show_points", PROP_BOOLEAN, PROP_NONE);		prop = RNA_def_property(srna, "show_points", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_DRAWDEBUG);		RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_LAYER_DRAWDEBUG);
RNA_def_property_ui_text(prop, "Show Points", "Draw the points which make up the strokes (for debugging purposes)");		RNA_def_property_ui_text(prop, "Show Points", "Draw the points which make up the strokes (for debugging purposes)");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

/* X-Ray */		/* X-Ray */
prop = RNA_def_property(srna, "show_x_ray", PROP_BOOLEAN, PROP_NONE);		prop = RNA_def_property(srna, "show_x_ray", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GP_LAYER_NO_XRAY);		RNA_def_property_boolean_negative_sdna(prop, NULL, "flag", GP_LAYER_NO_XRAY);
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Lines	static void rna_def_gpencil_layers_api(BlenderRNA brna, PropertyRNA cprop)

prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);		prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
RNA_def_property_int_funcs(prop,		RNA_def_property_int_funcs(prop,
"rna_GPencil_active_layer_index_get",		"rna_GPencil_active_layer_index_get",
"rna_GPencil_active_layer_index_set",		"rna_GPencil_active_layer_index_set",
"rna_GPencil_active_layer_index_range");		"rna_GPencil_active_layer_index_range");
RNA_def_property_ui_text(prop, "Active Layer Index", "Index of active grease pencil layer");		RNA_def_property_ui_text(prop, "Active Layer Index", "Index of active grease pencil layer");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA \| NA_SELECTED, NULL);		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA \| NA_SELECTED, NULL);
}

static void rna_def_gpencil_palettecolor(BlenderRNA *brna)
{
StructRNA *srna;
PropertyRNA *prop;

srna = RNA_def_struct(brna, "GPencilPaletteColor", NULL);
RNA_def_struct_sdna(srna, "bGPDpalettecolor");
RNA_def_struct_ui_text(srna, "Grease Pencil Palette color", "Collection of related colors");
RNA_def_struct_path_func(srna, "rna_GPencilPalette_color_path");

/* Stroke Drawing Color */
prop = RNA_def_property(srna, "color", PROP_FLOAT, PROP_COLOR_GAMMA);
RNA_def_property_float_sdna(prop, NULL, "color");
RNA_def_property_array(prop, 3);
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(prop, "Color", "Color for strokes");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

prop = RNA_def_property(srna, "alpha", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, NULL, "color[3]");
RNA_def_property_range(prop, 0.0, 1.0f);
RNA_def_property_ui_text(prop, "Opacity", "Color Opacity");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

/* Name */
prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
RNA_def_property_string_sdna(prop, NULL, "info");
RNA_def_property_ui_text(prop, "Name", "Color name");
RNA_def_property_string_funcs(prop, NULL, NULL, "rna_GPencilPaletteColor_info_set");
RNA_def_struct_name_property(srna, prop);
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

/* Fill Drawing Color */
prop = RNA_def_property(srna, "fill_color", PROP_FLOAT, PROP_COLOR_GAMMA);
RNA_def_property_float_sdna(prop, NULL, "fill");
RNA_def_property_array(prop, 3);
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(prop, "Fill Color", "Color for filling region bounded by each stroke");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

/* Fill alpha */
prop = RNA_def_property(srna, "fill_alpha", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, NULL, "fill[3]");
RNA_def_property_range(prop, 0.0, 1.0f);
RNA_def_property_ui_text(prop, "Fill Opacity", "Opacity for filling region bounded by each stroke");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

/* Flags */
prop = RNA_def_property(srna, "hide", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", PC_COLOR_HIDE);
RNA_def_property_ui_icon(prop, ICON_HIDE_OFF, 1);
RNA_def_property_ui_text(prop, "Hide", "Set color Visibility");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

prop = RNA_def_property(srna, "lock", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", PC_COLOR_LOCKED);
RNA_def_property_ui_icon(prop, ICON_UNLOCKED, 1);
RNA_def_property_ui_text(prop, "Locked", "Protect color from further editing and/or frame changes");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

prop = RNA_def_property(srna, "ghost", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", PC_COLOR_ONIONSKIN);
RNA_def_property_ui_icon(prop, ICON_GHOST_ENABLED, 0);
RNA_def_property_ui_text(prop, "Show in Ghosts", "Display strokes using this color when showing onion skins");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

/* Draw Style */
prop = RNA_def_property(srna, "use_volumetric_strokes", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", PC_COLOR_VOLUMETRIC);
RNA_def_property_ui_text(prop, "Volumetric Strokes", "Draw strokes as a series of circular blobs, resulting in "
"a volumetric effect");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

/* Use High quality fill */
prop = RNA_def_property(srna, "use_hq_fill", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", PC_COLOR_HQ_FILL);
RNA_def_property_ui_text(prop, "High Quality Fill", "Fill strokes using high quality to avoid glitches "
"(slower fps during animation play)");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

/* Read-only state props (for simpler UI code) */
prop = RNA_def_property(srna, "is_stroke_visible", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(prop, "rna_GPencilPaletteColor_is_stroke_visible_get", NULL);
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_ui_text(prop, "Is Stroke Visible", "True when opacity of stroke is set high enough to be visible");

prop = RNA_def_property(srna, "is_fill_visible", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(prop, "rna_GPencilPaletteColor_is_fill_visible_get", NULL);
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_ui_text(prop, "Is Fill Visible", "True when opacity of fill is set high enough to be visible");
}

/* palette colors api */
static void rna_def_gpencil_palettecolors_api(BlenderRNA brna, PropertyRNA cprop)
{
StructRNA *srna;
PropertyRNA *prop;

FunctionRNA *func;		/* Active Layer - As an enum (for selecting active layer for annotations) */
PropertyRNA *parm;		prop = RNA_def_property(srna, "active_note", PROP_ENUM, PROP_NONE);
		RNA_def_property_enum_funcs(prop,
RNA_def_property_srna(cprop, "GPencilPaletteColors");		"rna_GPencil_active_layer_index_get",
srna = RNA_def_struct(brna, "GPencilPaletteColors", NULL);		"rna_GPencil_active_layer_index_set",
RNA_def_struct_sdna(srna, "bGPDpalette");		"rna_GPencil_active_layer_itemf");
RNA_def_struct_ui_text(srna, "Palette colors", "Collection of palette colors");		RNA_def_property_enum_items(prop, DummyRNA_DEFAULT_items); /* purely dynamic, as it maps to user-data */
		RNA_def_property_ui_text(prop, "Active Note", "Note/Layer to add annotation strokes to");
func = RNA_def_function(srna, "new", "rna_GPencilPalette_color_new");
RNA_def_function_ui_description(func, "Add a new color to the palette");
parm = RNA_def_pointer(func, "color", "GPencilPaletteColor", "", "The newly created color");
RNA_def_function_return(func, parm);

func = RNA_def_function(srna, "remove", "rna_GPencilPalette_color_remove");
RNA_def_function_ui_description(func, "Remove a color from the palette");
RNA_def_function_flag(func, FUNC_USE_REPORTS);
parm = RNA_def_pointer(func, "color", "GPencilPaletteColor", "", "The color to remove");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED \| PARM_RNAPTR);
RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);

prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
RNA_def_property_struct_type(prop, "GPencilPaletteColor");
RNA_def_property_pointer_funcs(prop, "rna_GPencilPalette_active_color_get", "rna_GPencilPalette_active_color_set", NULL, NULL);
RNA_def_property_flag(prop, PROP_EDITABLE);
RNA_def_property_ui_text(prop, "Active Palette Color", "Current active color");

prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
RNA_def_property_int_funcs(prop,
"rna_GPencilPaletteColor_index_get",
"rna_GPencilPaletteColor_index_set",
"rna_GPencilPaletteColor_index_range");
RNA_def_property_ui_text(prop, "Active color Index", "Index of active palette color");
}

static void rna_def_gpencil_palette(BlenderRNA *brna)
{
StructRNA *srna;
PropertyRNA *prop;

srna = RNA_def_struct(brna, "GPencilPalette", NULL);
RNA_def_struct_sdna(srna, "bGPDpalette");
RNA_def_struct_ui_text(srna, "Grease Pencil Palette", "Collection of related palettes");
RNA_def_struct_path_func(srna, "rna_GPencilPalette_path");
RNA_def_struct_ui_icon(srna, ICON_COLOR);

/* Name */
prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
RNA_def_property_string_sdna(prop, NULL, "info");
RNA_def_property_ui_text(prop, "Name", "Palette name");
RNA_def_property_string_funcs(prop, NULL, NULL, "rna_GPencilPalette_info_set");
RNA_def_struct_name_property(srna, prop);
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

/* Colors */
prop = RNA_def_property(srna, "colors", PROP_COLLECTION, PROP_NONE);
RNA_def_property_collection_sdna(prop, NULL, "colors", NULL);
RNA_def_property_struct_type(prop, "GPencilPaletteColor");
RNA_def_property_ui_text(prop, "Colors", "Colors of the palette");
rna_def_gpencil_palettecolors_api(brna, prop);

}

static void rna_def_gpencil_palettes_api(BlenderRNA brna, PropertyRNA cprop)
{
StructRNA *srna;
PropertyRNA *prop;

FunctionRNA *func;
PropertyRNA *parm;

RNA_def_property_srna(cprop, "GreasePencilPalettes");
srna = RNA_def_struct(brna, "GreasePencilPalettes", NULL);
RNA_def_struct_sdna(srna, "bGPdata");
RNA_def_struct_ui_text(srna, "Grease Pencil Palettes", "Collection of grease pencil palettes");

func = RNA_def_function(srna, "new", "rna_GPencil_palette_new");
RNA_def_function_ui_description(func, "Add a new grease pencil palette");
parm = RNA_def_string(func, "name", "GPencilPalette", MAX_NAME, "Name", "Name of the palette");
RNA_def_parameter_flags(parm, 0, PARM_REQUIRED);
RNA_def_boolean(func, "set_active", true, "Set Active", "Activate the newly created palette");
parm = RNA_def_pointer(func, "palette", "GPencilPalette", "", "The newly created palette");
RNA_def_function_return(func, parm);

func = RNA_def_function(srna, "remove", "rna_GPencil_palette_remove");
RNA_def_function_ui_description(func, "Remove a grease pencil palette");
RNA_def_function_flag(func, FUNC_USE_REPORTS);
parm = RNA_def_pointer(func, "palette", "GPencilPalette", "", "The palette to remove");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED \| PARM_RNAPTR);
RNA_def_parameter_clear_flags(parm, PROP_THICK_WRAP, 0);

prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
RNA_def_property_struct_type(prop, "GPencilPalette");
RNA_def_property_pointer_funcs(prop, "rna_GPencil_active_palette_get", "rna_GPencil_active_palette_set",
NULL, NULL);
RNA_def_property_flag(prop, PROP_EDITABLE);
RNA_def_property_ui_text(prop, "Active Palette", "Current active palette");

prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
RNA_def_property_int_funcs(prop,
"rna_GPencilPalette_index_get",
"rna_GPencilPalette_index_set",
"rna_GPencilPalette_index_range");
RNA_def_property_ui_text(prop, "Active Palette Index", "Index of active palette");
}		}

static void rna_def_gpencil_data(BlenderRNA *brna)		static void rna_def_gpencil_data(BlenderRNA *brna)
{		{
StructRNA *srna;		StructRNA *srna;
PropertyRNA *prop;		PropertyRNA *prop;
FunctionRNA *func;		FunctionRNA *func;

		static float default_1[4] = { 0.6f, 0.6f, 0.6f, 0.5f };
		static float onion_dft1[3] = { 0.145098f, 0.419608f, 0.137255f }; /* green */
		static float onion_dft2[3] = { 0.125490f, 0.082353f, 0.529412f }; /* blue */

srna = RNA_def_struct(brna, "GreasePencil", "ID");		srna = RNA_def_struct(brna, "GreasePencil", "ID");
RNA_def_struct_sdna(srna, "bGPdata");		RNA_def_struct_sdna(srna, "bGPdata");
RNA_def_struct_ui_text(srna, "Grease Pencil", "Freehand annotation sketchbook");		RNA_def_struct_ui_text(srna, "Grease Pencil", "Freehand annotation sketchbook");
RNA_def_struct_ui_icon(srna, ICON_GREASEPENCIL);		RNA_def_struct_ui_icon(srna, ICON_GREASEPENCIL);

/* Layers */		/* Layers */
prop = RNA_def_property(srna, "layers", PROP_COLLECTION, PROP_NONE);		prop = RNA_def_property(srna, "layers", PROP_COLLECTION, PROP_NONE);
RNA_def_property_collection_sdna(prop, NULL, "layers", NULL);		RNA_def_property_collection_sdna(prop, NULL, "layers", NULL);
RNA_def_property_struct_type(prop, "GPencilLayer");		RNA_def_property_struct_type(prop, "GPencilLayer");
RNA_def_property_ui_text(prop, "Layers", "");		RNA_def_property_ui_text(prop, "Layers", "");
rna_def_gpencil_layers_api(brna, prop);		rna_def_gpencil_layers_api(brna, prop);

/* Palettes */
prop = RNA_def_property(srna, "palettes", PROP_COLLECTION, PROP_NONE);
RNA_def_property_collection_sdna(prop, NULL, "palettes", NULL);
RNA_def_property_struct_type(prop, "GPencilPalette");
RNA_def_property_ui_text(prop, "Palettes", "");
rna_def_gpencil_palettes_api(brna, prop);

/* Animation Data */		/* Animation Data */
rna_def_animdata_common(srna);		rna_def_animdata_common(srna);

		/* materials */
		prop = RNA_def_property(srna, "materials", PROP_COLLECTION, PROP_NONE);
		RNA_def_property_collection_sdna(prop, NULL, "mat", "totcol");
		RNA_def_property_struct_type(prop, "Material");
		RNA_def_property_ui_text(prop, "Materials", "");
		RNA_def_property_srna(prop, "IDMaterials"); /* see rna_ID.c */
		RNA_def_property_collection_funcs(prop, NULL, NULL, NULL, NULL, NULL, NULL, NULL, "rna_IDMaterials_assign_int");

		/* xray modes */
		prop = RNA_def_property(srna, "xray_mode", PROP_ENUM, PROP_NONE);
		RNA_def_property_enum_sdna(prop, NULL, "xray_mode");
		RNA_def_property_enum_items(prop, rna_enum_gpencil_xraymodes_items);
		RNA_def_property_ui_text(prop, "Xray", "");
		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

/* Flags */		/* Flags */
prop = RNA_def_property(srna, "use_stroke_edit_mode", PROP_BOOLEAN, PROP_NONE);		prop = RNA_def_property(srna, "use_stroke_edit_mode", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_STROKE_EDITMODE);		RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_STROKE_EDITMODE);
RNA_def_property_ui_text(prop, "Stroke Edit Mode", "Edit Grease Pencil strokes instead of viewport data");		RNA_def_property_ui_text(prop, "Stroke Edit Mode", "Edit Grease Pencil strokes instead of viewport data");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA \| ND_GPENCIL_EDITMODE, "rna_GPencil_editmode_update");		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA \| ND_GPENCIL_EDITMODE, "rna_GPencil_editmode_update");

		prop = RNA_def_property(srna, "is_stroke_paint_mode", PROP_BOOLEAN, PROP_NONE);
		RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_STROKE_PAINTMODE);
		RNA_def_property_ui_text(prop, "Stroke Paint Mode", "Draw Grease Pencil strokes on click/drag");
		RNA_def_property_clear_flag(prop, PROP_EDITABLE);
		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA \| ND_GPENCIL_EDITMODE, "rna_GPencil_editmode_update");

		prop = RNA_def_property(srna, "is_stroke_sculpt_mode", PROP_BOOLEAN, PROP_NONE);
		RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_STROKE_SCULPTMODE);
		RNA_def_property_ui_text(prop, "Stroke Sculpt Mode", "Sculpt Grease Pencil strokes instead of viewport data");
		RNA_def_property_clear_flag(prop, PROP_EDITABLE);
		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA \| ND_GPENCIL_EDITMODE, "rna_GPencil_editmode_update");

		prop = RNA_def_property(srna, "is_stroke_weight_mode", PROP_BOOLEAN, PROP_NONE);
		RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_STROKE_WEIGHTMODE);
		RNA_def_property_ui_text(prop, "Stroke Weight Paint Mode", "Grease Pencil weight paint");
		RNA_def_property_clear_flag(prop, PROP_EDITABLE);
		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA \| ND_GPENCIL_EDITMODE, "rna_GPencil_editmode_update");

prop = RNA_def_property(srna, "use_onion_skinning", PROP_BOOLEAN, PROP_NONE);		prop = RNA_def_property(srna, "use_onion_skinning", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_SHOW_ONIONSKINS);		RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_SHOW_ONIONSKINS);
RNA_def_property_boolean_funcs(prop, NULL, "rna_GPencil_use_onion_skinning_set");		RNA_def_property_ui_text(prop, "Onion Skins", "Show ghosts of the frames before and after the current frame");
RNA_def_property_ui_text(prop, "Onion Skins",		RNA_def_property_update(prop, NC_SCREEN \| NC_SCENE \| ND_TOOLSETTINGS \| ND_DATA \| NC_GPENCIL, "rna_GPencil_update");
"Show ghosts of the frames before and after the current frame, toggle to enable on active layer or disable all");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, NULL);

prop = RNA_def_property(srna, "show_stroke_direction", PROP_BOOLEAN, PROP_NONE);		prop = RNA_def_property(srna, "show_stroke_direction", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_SHOW_DIRECTION);		RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_SHOW_DIRECTION);
RNA_def_property_ui_text(prop, "Show Direction", "Show stroke drawing direction with a bigger green dot (start) "		RNA_def_property_ui_text(prop, "Show Direction", "Show stroke drawing direction with a bigger green dot (start) "
"and smaller red dot (end) points");		"and smaller red dot (end) points");
RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

		prop = RNA_def_property(srna, "show_constant_thickness", PROP_BOOLEAN, PROP_NONE);
		RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_STROKE_KEEPTHICKNESS);
		RNA_def_property_ui_text(prop, "Keep thickness", "Show stroke with same thickness when viewport zoom change");
		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

		prop = RNA_def_property(srna, "pixfactor", PROP_FLOAT, PROP_NONE);
		RNA_def_property_float_sdna(prop, NULL, "pixfactor");
		RNA_def_property_range(prop, 0.1f, 30.0f);
		RNA_def_property_ui_range(prop, 0.1f, 30.0f, 1, 2);
		RNA_def_property_ui_text(prop, "Scale", "Scale conversion factor for pixel size (use larger values for thicker lines)");
		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

		prop = RNA_def_property(srna, "use_multiedit", PROP_BOOLEAN, PROP_NONE);
		RNA_def_property_boolean_sdna(prop, NULL, "flag", GP_DATA_STROKE_MULTIEDIT);
		RNA_def_property_ui_text(prop, "MultiFrame", "Edit strokes from multiple grease pencil keyframes at the same time (keyframes must be selected to be included)");
		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

		prop = RNA_def_property(srna, "edit_line_color", PROP_FLOAT, PROP_COLOR_GAMMA);
		RNA_def_property_float_sdna(prop, NULL, "line_color");
		RNA_def_property_array(prop, 4);
		RNA_def_property_range(prop, 0.0f, 1.0f);
		RNA_def_property_float_array_default(prop, default_1);
		RNA_def_property_ui_text(prop, "Edit Line Color", "Color for editing line");
		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

		/* onion skinning */
		prop = RNA_def_property(srna, "ghost_before_range", PROP_INT, PROP_NONE);
		RNA_def_property_int_sdna(prop, NULL, "gstep");
		RNA_def_property_range(prop, 0, 120);
		RNA_def_property_int_default(prop, 1);
		RNA_def_property_ui_text(prop, "Frames Before",
		"Maximum number of frames to show before current frame "
		"(0 = don't show any frames before current)");
		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

		prop = RNA_def_property(srna, "ghost_after_range", PROP_INT, PROP_NONE);
		campbellbartonUnsubmitted Not Done Inline Actions Call `show_constant_thickness` campbellbarton: Call `show_constant_thickness`
		RNA_def_property_int_sdna(prop, NULL, "gstep_next");
		RNA_def_property_range(prop, 0, 120);
		RNA_def_property_int_default(prop, 1);
		RNA_def_property_ui_text(prop, "Frames After",
		"Maximum number of frames to show after current frame "
		"(0 = don't show any frames after current)");
		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

		prop = RNA_def_property(srna, "use_ghost_custom_colors", PROP_BOOLEAN, PROP_NONE);
		RNA_def_property_boolean_sdna(prop, NULL, "onion_flag", GP_ONION_GHOST_PREVCOL \| GP_ONION_GHOST_NEXTCOL);
		RNA_def_property_ui_text(prop, "Use Custom Ghost Colors", "Use custom colors for ghost frames");
		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

		prop = RNA_def_property(srna, "before_color", PROP_FLOAT, PROP_COLOR_GAMMA);
		RNA_def_property_float_sdna(prop, NULL, "gcolor_prev");
		RNA_def_property_array(prop, 3);
		RNA_def_property_range(prop, 0.0f, 1.0f);
		RNA_def_property_float_array_default(prop, onion_dft1);
		RNA_def_property_ui_text(prop, "Before Color", "Base color for ghosts before the active frame");
		RNA_def_property_update(prop, NC_SCREEN \| NC_SCENE \| ND_TOOLSETTINGS \| ND_DATA \| NC_GPENCIL, "rna_GPencil_update");

		prop = RNA_def_property(srna, "after_color", PROP_FLOAT, PROP_COLOR_GAMMA);
		RNA_def_property_float_sdna(prop, NULL, "gcolor_next");
		RNA_def_property_array(prop, 3);
		RNA_def_property_range(prop, 0.0f, 1.0f);
		RNA_def_property_float_array_default(prop, onion_dft2);
		RNA_def_property_ui_text(prop, "After Color", "Base color for ghosts after the active frame");
		RNA_def_property_update(prop, NC_SCREEN \| NC_SCENE \| ND_TOOLSETTINGS \| ND_DATA \| NC_GPENCIL, "rna_GPencil_update");

		prop = RNA_def_property(srna, "use_ghosts_always", PROP_BOOLEAN, PROP_NONE);
		RNA_def_property_boolean_sdna(prop, NULL, "onion_flag", GP_ONION_GHOST_ALWAYS);
		RNA_def_property_ui_text(prop, "Always Show Ghosts",
		"Ghosts are shown in renders and animation playback. Useful for special effects (e.g. motion blur)");
		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

		prop = RNA_def_property(srna, "onion_mode", PROP_ENUM, PROP_NONE);
		RNA_def_property_enum_sdna(prop, NULL, "onion_mode");
		RNA_def_property_enum_items(prop, rna_enum_gpencil_onion_modes_items);
		RNA_def_property_ui_text(prop, "Mode", "Mode to display frames");
		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

		campbellbartonUnsubmitted Not Done Inline Actions Should be an RNA function, reading an attr should not do big lookups like this. For other counting attrs too. campbellbarton: Should be an RNA function, reading an attr should not do big lookups like this. For other…
		prop = RNA_def_property(srna, "use_onion_fade", PROP_BOOLEAN, PROP_NONE);
		RNA_def_property_boolean_sdna(prop, NULL, "onion_flag", GP_ONION_FADE);
		RNA_def_property_ui_text(prop, "Fade",
		"Display onion keyframes with a fade in color transparency");
		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

		prop = RNA_def_property(srna, "use_onion_loop", PROP_BOOLEAN, PROP_NONE);
		RNA_def_property_boolean_sdna(prop, NULL, "onion_flag", GP_ONION_LOOP);
		RNA_def_property_ui_text(prop, "Loop",
		"Display first onion keyframes using next frame color to show indication of loop start frame");
		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

		prop = RNA_def_property(srna, "onion_factor", PROP_FLOAT, PROP_NONE);
		RNA_def_property_float_sdna(prop, NULL, "onion_factor");
		RNA_def_property_float_default(prop, 0.5f);
		RNA_def_property_range(prop, 0.0, 1.0f);
		RNA_def_property_ui_text(prop, "Onion Opacity", "Change fade opacity of displayed onion frames");
		RNA_def_property_update(prop, NC_GPENCIL \| ND_DATA, "rna_GPencil_update");

/* API Functions */		/* API Functions */
func = RNA_def_function(srna, "clear", "rna_GPencil_clear");		func = RNA_def_function(srna, "clear", "rna_GPencil_clear");
RNA_def_function_ui_description(func, "Remove all the grease pencil data");		RNA_def_function_ui_description(func, "Remove all the grease pencil data");
}		}

/* --- */		/* --- */

void RNA_def_gpencil(BlenderRNA *brna)		void RNA_def_gpencil(BlenderRNA *brna)
{		{
rna_def_gpencil_data(brna);		rna_def_gpencil_data(brna);

rna_def_gpencil_layer(brna);		rna_def_gpencil_layer(brna);
rna_def_gpencil_frame(brna);		rna_def_gpencil_frame(brna);
rna_def_gpencil_triangle(brna);
rna_def_gpencil_stroke(brna);		rna_def_gpencil_stroke(brna);
rna_def_gpencil_stroke_point(brna);		rna_def_gpencil_stroke_point(brna);
		rna_def_gpencil_triangle(brna);

rna_def_gpencil_palette(brna);		rna_def_gpencil_mvert_group(brna);
rna_def_gpencil_palettecolor(brna);
}		}

#endif		#endif