kannonier8/blender
1
0
Fork 0
forked from bartvdbraak/blender
Code Pull Requests Activity

RNA

Browse Source 
* Added icon to property and enum property items. The latter is
  responsible for the large number of files changed.
* For RNA functions, added PROP_RNAPTR flag to ask for a PointerRNA
  as argument instead of a C pointer, instead of doing it implicitly
  with the AnyType type.

* Material: properly wrap diffuse/specular param variables, and
  rename some things for consistency.
* MaterialTextureSlot: added "enabled" property (ma->septex).
* Image: make animated property editable.
* Image Editor: make some things editable, notifiers, respect state.
* Context: fix issue with screen not being set as ID.
This commit is contained in:
Brecht Van Lommel 2009-06-16 00:52:21 +00:00
parent 32cf82dbb3
commit 51fbc95e8c
81 changed files with 2189 additions and 1971 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
source/blender/blenkernel/intern/ipo.c
View File

@ -545,7 +545,7 @@ static char *material_adrcodes_to_paths (int adrcode, int *array_index)
return "ambient";
case MA_SPEC:
return "specularity";
return "specular_reflection";
case MA_HARD:
return "specular_hardness";

14
source/blender/editors/animation/anim_channels.c
View File

@ -721,17 +721,17 @@ enum {
/* defines for setting animation-channel flags */
EnumPropertyItem prop_animchannel_setflag_types[] = {
{ACHANNEL_SETFLAG_CLEAR, "DISABLE", "Disable", ""},
{ACHANNEL_SETFLAG_ADD, "ENABLE", "Enable", ""},
{ACHANNEL_SETFLAG_TOGGLE, "TOGGLE", "Toggle", ""},
{0, NULL, NULL, NULL}
{ACHANNEL_SETFLAG_CLEAR, "DISABLE", 0, "Disable", ""},
{ACHANNEL_SETFLAG_ADD, "ENABLE", 0, "Enable", ""},
{ACHANNEL_SETFLAG_TOGGLE, "TOGGLE", 0, "Toggle", ""},
{0, NULL, 0, NULL, NULL}
};
/* defines for set animation-channel settings */
EnumPropertyItem prop_animchannel_settings_types[] = {
{ACHANNEL_SETTING_PROTECT, "PROTECT", "Protect", ""},
{ACHANNEL_SETTING_MUTE, "MUTE", "Mute", ""},
{0, NULL, NULL, NULL}
{ACHANNEL_SETTING_PROTECT, "PROTECT", 0, "Protect", ""},
{ACHANNEL_SETTING_MUTE, "MUTE", 0, "Mute", ""},
{0, NULL, 0, NULL, NULL}
};

8
source/blender/editors/animation/keyingsets.c
View File

@ -106,10 +106,10 @@ void ANIM_OT_keyingset_add_destination (wmOperatorType *ot)
{
// XXX: this is also defined in rna_animation.c
static EnumPropertyItem prop_mode_grouping_items[] = {
{KSP_GROUP_NAMED, "NAMED", "Named Group", ""},
{KSP_GROUP_NONE, "NONE", "None", ""},
{KSP_GROUP_KSNAME, "KEYINGSET", "Keying Set Name", ""},
{0, NULL, NULL, NULL}};
{KSP_GROUP_NAMED, "NAMED", 0, "Named Group", ""},
{KSP_GROUP_NONE, "NONE", 0, "None", ""},
{KSP_GROUP_KSNAME, "KEYINGSET", 0, "Keying Set Name", ""},
{0, NULL, 0, NULL, NULL}};
/* identifiers */
ot->name= "Add Keying Set Destination";

30
source/blender/editors/armature/editarmature.c
View File

@ -1957,9 +1957,9 @@ void auto_align_ebone_tocursor(Scene *scene, View3D *v3d, EditBone *ebone)
static EnumPropertyItem prop_calc_roll_types[] = {
{0, "GLOBALUP", "Z-Axis Up", ""},
{1, "CURSOR", "Z-Axis to Cursor", ""},
{0, NULL, NULL, NULL}
{0, "GLOBALUP", 0, "Z-Axis Up", ""},
{1, "CURSOR", 0, "Z-Axis to Cursor", ""},
{0, NULL, 0, NULL, NULL}
};
static int armature_calc_roll_exec(bContext *C, wmOperator *op)
@ -3489,9 +3489,9 @@ static int armature_subdivs_exec(bContext *C, wmOperator *op)
void ARMATURE_OT_subdivs(wmOperatorType *ot)
{
static EnumPropertyItem type_items[]= {
{0, "SIMPLE", "Simple", ""},
{1, "MULTI", "Multi", ""},
{0, NULL, NULL}};
{0, "SIMPLE", 0, "Simple", ""},
{1, "MULTI", 0, "Multi", ""},
{0, NULL, 0, NULL, NULL}};
/* identifiers */
ot->name= "subdivs";
@ -3669,9 +3669,9 @@ static void bone_connect_to_new_parent(ListBase *edbo, EditBone *selbone, EditBo
}
static EnumPropertyItem prop_editarm_make_parent_types[] = {
{ARM_PAR_CONNECT, "CONNECTED", "Connected", ""},
{ARM_PAR_OFFSET, "OFFSET", "Keep Offset", ""},
{0, NULL, NULL, NULL}
{ARM_PAR_CONNECT, "CONNECTED", 0, "Connected", ""},
{ARM_PAR_OFFSET, "OFFSET", 0, "Keep Offset", ""},
{0, NULL, 0, NULL, NULL}
};
static int armature_parent_set_exec(bContext *C, wmOperator *op)
@ -3785,9 +3785,9 @@ void ARMATURE_OT_parent_set(wmOperatorType *ot)
}
static EnumPropertyItem prop_editarm_clear_parent_types[] = {
{1, "CLEAR", "Clear Parent", ""},
{2, "DISCONNECT", "Disconnect Bone", ""},
{0, NULL, NULL, NULL}
{1, "CLEAR", 0, "Clear Parent", ""},
{2, "DISCONNECT", 0, "Disconnect Bone", ""},
{0, NULL, 0, NULL, NULL}
};
static void editbone_clear_parent(EditBone *ebone, int mode)
@ -3973,9 +3973,9 @@ static int armature_select_hierarchy_exec(bContext *C, wmOperator *op)
void ARMATURE_OT_select_hierarchy(wmOperatorType *ot)
{
static EnumPropertyItem direction_items[]= {
{BONE_SELECT_PARENT, "PARENT", "Select Parent", ""},
{BONE_SELECT_CHILD, "CHILD", "Select Child", ""},
{0, NULL, NULL, NULL}
{BONE_SELECT_PARENT, "PARENT", 0, "Select Parent", ""},
{BONE_SELECT_CHILD, "CHILD", 0, "Select Child", ""},
{0, NULL, 0, NULL, NULL}
};
/* identifiers */

6
source/blender/editors/armature/poseobject.c
View File

@ -500,9 +500,9 @@ static int pose_select_hierarchy_exec(bContext *C, wmOperator *op)
void POSE_OT_select_hierarchy(wmOperatorType *ot)
{
static EnumPropertyItem direction_items[]= {
{BONE_SELECT_PARENT, "PARENT", "Select Parent", ""},
{BONE_SELECT_CHILD, "CHILD", "Select Child", ""},
{0, NULL, NULL, NULL}
{BONE_SELECT_PARENT, "PARENT", 0, "Select Parent", ""},
{BONE_SELECT_CHILD, "CHILD", 0, "Select Child", ""},
{0, NULL, 0, NULL, NULL}
};
/* identifiers */

38
source/blender/editors/curve/editcurve.c
View File

@ -2475,12 +2475,12 @@ static int set_spline_type_exec(bContext *C, wmOperator *op)
void CURVE_OT_spline_type_set(wmOperatorType *ot)
{
static EnumPropertyItem type_items[]= {
{CU_POLY, "POLY", "Poly", ""},
{CU_BEZIER, "BEZIER", "Bezier", ""},
{CU_CARDINAL, "CARDINAL", "Cardinal", ""},
{CU_BSPLINE, "B_SPLINE", "B-Spline", ""},
{CU_NURBS, "NURBS", "NURBS", ""},
{0, NULL, NULL, NULL}};
{CU_POLY, "POLY", 0, "Poly", ""},
{CU_BEZIER, "BEZIER", 0, "Bezier", ""},
{CU_CARDINAL, "CARDINAL", 0, "Cardinal", ""},
{CU_BSPLINE, "B_SPLINE", 0, "B-Spline", ""},
{CU_NURBS, "NURBS", 0, "NURBS", ""},
{0, NULL, 0, NULL, NULL}};
/* identifiers */
ot->name= "Set Spline Type";
@ -2516,12 +2516,12 @@ static int set_handle_type_exec(bContext *C, wmOperator *op)
void CURVE_OT_handle_type_set(wmOperatorType *ot)
{
static EnumPropertyItem type_items[]= {
{1, "AUTOMATIC", "Automatic", ""},
{2, "VECTOR", "Vector", ""},
{3, "TOGGLE_FREE_ALIGN", "Toggle Free/Align", ""},
{5, "ALIGN", "Align", ""},
{6, "FREE_ALIGN", "Free Align", ""},
{0, NULL, NULL, NULL}};
{1, "AUTOMATIC", 0, "Automatic", ""},
{2, "VECTOR", 0, "Vector", ""},
{3, "TOGGLE_FREE_ALIGN", 0, "Toggle Free/Align", ""},
{5, "ALIGN", 0, "Align", ""},
{6, "FREE_ALIGN", 0, "Free Align", ""},
{0, NULL, 0, NULL, NULL}};
/* identifiers */
ot->name= "Set Handle Type";
@ -3582,9 +3582,9 @@ static int toggle_cyclic_invoke(bContext *C, wmOperator *op, wmEvent *event)
void CURVE_OT_cyclic_toggle(wmOperatorType *ot)
{
static EnumPropertyItem direction_items[]= {
{0, "CYCLIC_U", "Cyclic U", ""},
{1, "CYCLIC_V", "Cyclic V", ""},
{0, NULL, NULL, NULL}};
{0, "CYCLIC_U", 0, "Cyclic U", ""},
{1, "CYCLIC_V", 0, "Cyclic V", ""},
{0, NULL, 0, NULL, NULL}};
/* identifiers */
ot->name= "Toggle Cyclic";
@ -4530,10 +4530,10 @@ static int delete_invoke(bContext *C, wmOperator *op, wmEvent *event)
void CURVE_OT_delete(wmOperatorType *ot)
{
static EnumPropertyItem type_items[] = {
{0, "SELECTED", "Selected", ""},
{1, "SEGMENT", "Segment", ""},
{2, "ALL", "All", ""},
{0, NULL, NULL, NULL}};
{0, "SELECTED", 0, "Selected", ""},
{1, "SEGMENT", 0, "Segment", ""},
{2, "ALL", 0, "All", ""},
{0, NULL, 0, NULL, NULL}};
/* identifiers */
ot->name= "Delete";

50
source/blender/editors/curve/editfont.c
View File

@ -607,10 +607,10 @@ static int kill_selection(Object *obedit, int ins) /* 1 == new character */
/******************* set style operator ********************/
static EnumPropertyItem style_items[]= {
{CU_BOLD, "BOLD", "Bold", ""},
{CU_ITALIC, "ITALIC", "Italic", ""},
{CU_UNDERLINE, "UNDERLINE", "Underline", ""},
{0, NULL, NULL, NULL}};
{CU_BOLD, "BOLD", 0, "Bold", ""},
{CU_ITALIC, "ITALIC", 0, "Italic", ""},
{CU_UNDERLINE, "UNDERLINE", 0, "Underline", ""},
{0, NULL, 0, NULL, NULL}};
static int set_style(bContext *C, int style, int clear)
{
@ -873,17 +873,17 @@ void FONT_OT_text_paste(wmOperatorType *ot)
/************************ move operator ************************/
static EnumPropertyItem move_type_items[]= {
{LINE_BEGIN, "LINE_BEGIN", "Line Begin", ""},
{LINE_END, "LINE_END", "Line End", ""},
{PREV_CHAR, "PREVIOUS_CHARACTER", "Previous Character", ""},
{NEXT_CHAR, "NEXT_CHARACTER", "Next Character", ""},
{PREV_WORD, "PREVIOUS_WORD", "Previous Word", ""},
{NEXT_WORD, "NEXT_WORD", "Next Word", ""},
{PREV_LINE, "PREVIOUS_LINE", "Previous Line", ""},
{NEXT_LINE, "NEXT_LINE", "Next Line", ""},
{PREV_PAGE, "PREVIOUS_PAGE", "Previous Page", ""},
{NEXT_PAGE, "NEXT_PAGE", "Next Page", ""},
{0, NULL, NULL, NULL}};
{LINE_BEGIN, "LINE_BEGIN", 0, "Line Begin", ""},
{LINE_END, "LINE_END", 0, "Line End", ""},
{PREV_CHAR, "PREVIOUS_CHARACTER", 0, "Previous Character", ""},
{NEXT_CHAR, "NEXT_CHARACTER", 0, "Next Character", ""},
{PREV_WORD, "PREVIOUS_WORD", 0, "Previous Word", ""},
{NEXT_WORD, "NEXT_WORD", 0, "Next Word", ""},
{PREV_LINE, "PREVIOUS_LINE", 0, "Previous Line", ""},
{NEXT_LINE, "NEXT_LINE", 0, "Next Line", ""},
{PREV_PAGE, "PREVIOUS_PAGE", 0, "Previous Page", ""},
{NEXT_PAGE, "NEXT_PAGE", 0, "Next Page", ""},
{0, NULL, 0, NULL, NULL}};
static int move_cursor(bContext *C, int type, int select)
{
@ -1164,13 +1164,13 @@ void FONT_OT_line_break(wmOperatorType *ot)
/******************* delete operator **********************/
static EnumPropertyItem delete_type_items[]= {
{DEL_ALL, "ALL", "All", ""},
{DEL_NEXT_CHAR, "NEXT_CHARACTER", "Next Character", ""},
{DEL_PREV_CHAR, "PREVIOUS_CHARACTER", "Previous Character", ""},
{DEL_SELECTION, "SELECTION", "Selection", ""},
{DEL_NEXT_SEL, "NEXT_OR_SELECTION", "Next or Selection", ""},
{DEL_PREV_SEL, "PREVIOUS_OR_SELECTION", "Previous or Selection", ""},
{0, NULL, NULL, NULL}};
{DEL_ALL, "ALL", 0, "All", ""},
{DEL_NEXT_CHAR, "NEXT_CHARACTER", 0, "Next Character", ""},
{DEL_PREV_CHAR, "PREVIOUS_CHARACTER", 0, "Previous Character", ""},
{DEL_SELECTION, "SELECTION", 0, "Selection", ""},
{DEL_NEXT_SEL, "NEXT_OR_SELECTION", 0, "Next or Selection", ""},
{DEL_PREV_SEL, "PREVIOUS_OR_SELECTION", 0, "Previous or Selection", ""},
{0, NULL, 0, NULL, NULL}};
static int delete_exec(bContext *C, wmOperator *op)
{
@ -1465,9 +1465,9 @@ void free_editText(Object *obedit)
/********************** set case operator *********************/
static EnumPropertyItem case_items[]= {
{CASE_LOWER, "LOWER", "Lower", ""},
{CASE_UPPER, "UPPER", "Upper", ""},
{0, NULL, NULL, NULL}};
{CASE_LOWER, "LOWER", 0, "Lower", ""},
{CASE_UPPER, "UPPER", 0, "Upper", ""},
{0, NULL, 0, NULL, NULL}};
static int set_case(bContext *C, int ccase)
{

62
source/blender/editors/interface/interface_api.c
View File

@ -35,10 +35,10 @@
#include "UI_interface.h"
#include "UI_resources.h"
#define DEF_ICON(name) {name, #name, #name, ""},
#define DEF_ICON(name) {name, #name, 0, #name, ""},
static EnumPropertyItem icon_items[] = {
#include "UI_icons.h"
{0, NULL, NULL, NULL}};
{0, NULL, 0, NULL, NULL}};
#undef DEF_ICON
static void api_ui_item_common(FunctionRNA *func)
@ -62,16 +62,26 @@ static void api_ui_item_op_common(FunctionRNA *func)
RNA_def_property_flag(parm, PROP_REQUIRED);
}
static void api_ui_item_rna_common(FunctionRNA *func)
{
PropertyRNA *parm;
parm= RNA_def_pointer(func, "data", "AnyType", "", "Data from which to take property.");
RNA_def_property_flag(parm, PROP_REQUIRED|PROP_RNAPTR);
parm= RNA_def_string(func, "property", "", 0, "", "Identifier of property in data.");
RNA_def_property_flag(parm, PROP_REQUIRED);
}
void RNA_api_ui_layout(StructRNA *srna)
{
FunctionRNA *func;
PropertyRNA *parm;
static EnumPropertyItem curve_type_items[] = {
{0, "NONE", "None", ""},
{'v', "VECTOR", "Vector", ""},
{'c', "COLOR", "Color", ""},
{0, NULL, NULL, NULL}};
{0, "NONE", 0, "None", ""},
{'v', "VECTOR", 0, "Vector", ""},
{'c', "COLOR", 0, "Color", ""},
{0, NULL, 0, NULL, NULL}};
/* simple layout specifiers */
func= RNA_def_function(srna, "row", "uiLayoutRow");
@ -104,33 +114,21 @@ void RNA_api_ui_layout(StructRNA *srna)
/* items */
func= RNA_def_function(srna, "itemR", "uiItemR");
api_ui_item_common(func);
parm= RNA_def_pointer(func, "data", "AnyType", "", "Data from which to take property.");
RNA_def_property_flag(parm, PROP_REQUIRED);
parm= RNA_def_string(func, "property", "", 0, "", "Identifier of property in data.");
RNA_def_property_flag(parm, PROP_REQUIRED);
api_ui_item_rna_common(func);
RNA_def_boolean(func, "expand", 0, "", "Expand button to show more detail.");
RNA_def_boolean(func, "slider", 0, "", "Use slider widget for numeric values.");
RNA_def_boolean(func, "toggle", 0, "", "Use toggle widget for boolean values.");
func= RNA_def_function(srna, "items_enumR", "uiItemsEnumR");
parm= RNA_def_pointer(func, "data", "AnyType", "", "Data from which to take property.");
RNA_def_property_flag(parm, PROP_REQUIRED);
parm= RNA_def_string(func, "property", "", 0, "", "Identifier of property in data.");
RNA_def_property_flag(parm, PROP_REQUIRED);
api_ui_item_rna_common(func);
func= RNA_def_function(srna, "item_menu_enumR", "uiItemMenuEnumR");
api_ui_item_common(func);
parm= RNA_def_pointer(func, "data", "AnyType", "", "Data from which to take property.");
RNA_def_property_flag(parm, PROP_REQUIRED);
parm= RNA_def_string(func, "property", "", 0, "", "Identifier of property in data.");
RNA_def_property_flag(parm, PROP_REQUIRED);
api_ui_item_rna_common(func);
/*func= RNA_def_function(srna, "item_enumR", "uiItemEnumR");
api_ui_item_common(func);
parm= RNA_def_pointer(func, "data", "AnyType", "", "Data from which to take property.");
RNA_def_property_flag(parm, PROP_REQUIRED);
parm= RNA_def_string(func, "property", "", 0, "", "Identifier of property in data.");
RNA_def_property_flag(parm, PROP_REQUIRED);
api_ui_item_rna_common(func);
parm= RNA_def_string(func, "value", "", 0, "", "Enum property value.");
RNA_def_property_flag(parm, PROP_REQUIRED);*/
@ -200,7 +198,7 @@ void RNA_api_ui_layout(StructRNA *srna)
parm= RNA_def_string(func, "name", "", 0, "Name", "Name of entry in the context.");
RNA_def_property_flag(parm, PROP_REQUIRED);
parm= RNA_def_pointer(func, "data", "AnyType", "", "Pointer to put in context.");
RNA_def_property_flag(parm, PROP_REQUIRED);
RNA_def_property_flag(parm, PROP_REQUIRED|PROP_RNAPTR);
/* templates */
func= RNA_def_function(srna, "template_header", "uiTemplateHeader");
@ -210,23 +208,20 @@ void RNA_api_ui_layout(StructRNA *srna)
func= RNA_def_function(srna, "template_ID", "uiTemplateID");
parm= RNA_def_pointer(func, "context", "Context", "", "Current context.");
RNA_def_property_flag(parm, PROP_REQUIRED);
parm= RNA_def_pointer(func, "data", "AnyType", "", "Data from which to take property.");
RNA_def_property_flag(parm, PROP_REQUIRED);
parm= RNA_def_string(func, "property", "", 0, "", "Identifier of pointer property in data.");
RNA_def_property_flag(parm, PROP_REQUIRED);
api_ui_item_rna_common(func);
RNA_def_string(func, "new", "", 0, "", "Operator identifier to create a new ID block.");
RNA_def_string(func, "open", "", 0, "", "Operator identifier to open a new ID block.");
RNA_def_string(func, "unlink", "", 0, "", "Operator identifier to unlink the ID block.");
func= RNA_def_function(srna, "template_modifier", "uiTemplateModifier");
parm= RNA_def_pointer(func, "data", "AnyType", "", "Modifier data.");
RNA_def_property_flag(parm, PROP_REQUIRED);
parm= RNA_def_pointer(func, "data", "Modifier", "", "Modifier data.");
RNA_def_property_flag(parm, PROP_REQUIRED|PROP_RNAPTR);
parm= RNA_def_pointer(func, "layout", "UILayout", "", "Sub-layout to put items in.");
RNA_def_function_return(func, parm);
func= RNA_def_function(srna, "template_constraint", "uiTemplateConstraint");
parm= RNA_def_pointer(func, "data", "AnyType", "", "Constraint data.");
RNA_def_property_flag(parm, PROP_REQUIRED);
parm= RNA_def_pointer(func, "data", "Constraint", "", "Constraint data.");
RNA_def_property_flag(parm, PROP_REQUIRED|PROP_RNAPTR);
parm= RNA_def_pointer(func, "layout", "UILayout", "", "Sub-layout to put items in.");
RNA_def_function_return(func, parm);
@ -245,9 +240,6 @@ void RNA_api_ui_layout(StructRNA *srna)
RNA_def_boolean(func, "expand", 0, "", "Expand button to show more detail.");
func= RNA_def_function(srna, "template_layers", "uiTemplateLayers");
parm= RNA_def_pointer(func, "data", "AnyType", "", "Data from which to take property.");
RNA_def_property_flag(parm, PROP_REQUIRED);
parm= RNA_def_string(func, "property", "", 0, "", "Identifier of pointer property in data.");
RNA_def_property_flag(parm, PROP_REQUIRED);
api_ui_item_rna_common(func);
}

8
source/blender/editors/mesh/editmesh.c
View File

@ -1434,10 +1434,10 @@ void remake_editMesh(Scene *scene, Object *ob)
/* *************** Operator: separate parts *************/
static EnumPropertyItem prop_separate_types[] = {
{0, "SELECTED", "Selection", ""},
{1, "MATERIAL", "By Material", ""},
{2, "LOOSE", "By loose parts", ""},
{0, NULL, NULL, NULL}
{0, "SELECTED", 0, "Selection", ""},
{1, "MATERIAL", 0, "By Material", ""},
{2, "LOOSE", 0, "By loose parts", ""},
{0, NULL, 0, NULL, NULL}
};
/* return 1: success */

8
source/blender/editors/mesh/editmesh_loop.c
View File

@ -458,10 +458,10 @@ typedef struct CutCurve {
#define KNIFE_MULTICUT 3
static EnumPropertyItem knife_items[]= {
{KNIFE_EXACT, "EXACT", "Exact", ""},
{KNIFE_MIDPOINT, "MIDPOINTS", "Midpoints", ""},
{KNIFE_MULTICUT, "MULTICUT", "Multicut", ""},
{0, NULL, NULL}
{KNIFE_EXACT, "EXACT", 0, "Exact", ""},
{KNIFE_MIDPOINT, "MIDPOINTS", 0, "Midpoints", ""},
{KNIFE_MULTICUT, "MULTICUT", 0, "Multicut", ""},
{0, NULL, 0, NULL, NULL}
};
/* seg_intersect() Determines if and where a mouse trail intersects an EditEdge */

46
source/blender/editors/mesh/editmesh_mods.c
View File

@ -655,13 +655,13 @@ FACES GROUP
*/
static EnumPropertyItem prop_simface_types[] = {
{1, "MATERIAL", "Material", ""},
{2, "IMAGE", "Image", ""},
{3, "AREA", "Area", ""},
{4, "PERIMETER", "Perimeter", ""},
{5, "NORMAL", "Normal", ""},
{6, "COPLANAR", "Co-planar", ""},
{0, NULL, NULL, NULL}
{1, "MATERIAL", 0, "Material", ""},
{2, "IMAGE", 0, "Image", ""},
{3, "AREA", 0, "Area", ""},
{4, "PERIMETER", 0, "Perimeter", ""},
{5, "NORMAL", 0, "Normal", ""},
{6, "COPLANAR", 0, "Co-planar", ""},
{0, NULL, 0, NULL, NULL}
};
@ -849,14 +849,14 @@ EDGE GROUP
*/
static EnumPropertyItem prop_simedge_types[] = {
{1, "LENGTH", "Length", ""},
{2, "DIR", "Direction", ""},
{3, "FACE", "Amount of Vertices in Face", ""},
{4, "FACE_ANGLE", "Face Angles", ""},
{5, "CREASE", "Crease", ""},
{6, "SEAM", "Seam", ""},
{7, "SHARP", "Sharpness", ""},
{0, NULL, NULL, NULL}
{1, "LENGTH", 0, "Length", ""},
{2, "DIR", 0, "Direction", ""},
{3, "FACE", 0, "Amount of Vertices in Face", ""},
{4, "FACE_ANGLE", 0, "Face Angles", ""},
{5, "CREASE", 0, "Crease", ""},
{6, "SEAM", 0, "Seam", ""},
{7, "SHARP", 0, "Sharpness", ""},
{0, NULL, 0, NULL, NULL}
};
static int similar_edge_select__internal(Scene *scene, EditMesh *em, int mode)
@ -1105,10 +1105,10 @@ VERT GROUP
mode 3: same vertex groups
*/
static EnumPropertyItem prop_simvertex_types[] = {
{0, "NORMAL", "Normal", ""},
{1, "FACE", "Amount of Vertices in Face", ""},
{2, "VGROUP", "Vertex Groups", ""},
{0, NULL, NULL, NULL}
{0, "NORMAL", 0, "Normal", ""},
{1, "FACE", 0, "Amount of Vertices in Face", ""},
{2, "VGROUP", 0, "Vertex Groups", ""},
{0, NULL, 0, NULL, NULL}
};
@ -3537,10 +3537,10 @@ static void mesh_selection_type(Scene *scene, EditMesh *em, int val)
}
static EnumPropertyItem prop_mesh_edit_types[] = {
{1, "VERT", "Vertices", ""},
{2, "EDGE", "Edges", ""},
{3, "FACE", "Faces", ""},
{0, NULL, NULL, NULL}
{1, "VERT", 0, "Vertices", ""},
{2, "EDGE", 0, "Edges", ""},
{3, "FACE", 0, "Faces", ""},
{0, NULL, 0, NULL, NULL}
};
static int mesh_selection_type_exec(bContext *C, wmOperator *op)

26
source/blender/editors/mesh/editmesh_tools.c
View File

@ -1273,14 +1273,14 @@ void delete_mesh(Object *obedit, EditMesh *em, wmOperator *op, int event)
/* Note, these values must match delete_mesh() event values */
static EnumPropertyItem prop_mesh_delete_types[] = {
{10,"VERT", "Vertices", ""},
{1, "EDGE", "Edges", ""},
{2, "FACE", "Faces", ""},
{3, "ALL", "All", ""},
{4, "EDGE_FACE","Edges & Faces", ""},
{5, "ONLY_FACE","Only Faces", ""},
{6, "EDGE_LOOP","Edge Loop", ""},
{0, NULL, NULL, NULL}
{10,"VERT", 0, "Vertices", ""},
{1, "EDGE", 0, "Edges", ""},
{2, "FACE", 0, "Faces", ""},
{3, "ALL", 0, "All", ""},
{4, "EDGE_FACE",0, "Edges & Faces", ""},
{5, "ONLY_FACE",0, "Only Faces", ""},
{6, "EDGE_LOOP",0, "Edge Loop", ""},
{0, NULL, 0, NULL, NULL}
};
static int delete_mesh_exec(bContext *C, wmOperator *op)
@ -6646,11 +6646,11 @@ static int subdivs_exec(bContext *C, wmOperator *op)
void MESH_OT_subdivs(wmOperatorType *ot)
{
static EnumPropertyItem type_items[]= {
{0, "SIMPLE", "Simple", ""},
{1, "MULTI", "Multi", ""},
{2, "FRACTAL", "Fractal", ""},
{3, "SMOOTH", "Smooth", ""},
{0, NULL, NULL}};
{0, "SIMPLE", 0, "Simple", ""},
{1, "MULTI", 0, "Multi", ""},
{2, "FRACTAL", 0, "Fractal", ""},
{3, "SMOOTH", 0, "Smooth", ""},
{0, NULL, 0, NULL, NULL}};
/* identifiers */
ot->name= "subdivs";

144
source/blender/editors/object/object_edit.c
View File

@ -244,17 +244,17 @@ void ED_object_base_init_from_view(bContext *C, Base *base)
/* ******************* add object operator ****************** */
static EnumPropertyItem prop_object_types[] = {
{OB_EMPTY, "EMPTY", "Empty", ""},
{OB_MESH, "MESH", "Mesh", ""},
{OB_CURVE, "CURVE", "Curve", ""},
{OB_SURF, "SURFACE", "Surface", ""},
{OB_FONT, "TEXT", "Text", ""},
{OB_MBALL, "META", "Meta", ""},
{OB_LAMP, "LAMP", "Lamp", ""},
{OB_CAMERA, "CAMERA", "Camera", ""},
{OB_ARMATURE, "ARMATURE", "Armature", ""},
{OB_LATTICE, "LATTICE", "Lattice", ""},
{0, NULL, NULL, NULL}
{OB_EMPTY, "EMPTY", 0, "Empty", ""},
{OB_MESH, "MESH", 0, "Mesh", ""},
{OB_CURVE, "CURVE", 0, "Curve", ""},
{OB_SURF, "SURFACE", 0, "Surface", ""},
{OB_FONT, "TEXT", 0, "Text", ""},
{OB_MBALL, "META", 0, "Meta", ""},
{OB_LAMP, "LAMP", 0, "Lamp", ""},
{OB_CAMERA, "CAMERA", 0, "Camera", ""},
{OB_ARMATURE, "ARMATURE", 0, "Armature", ""},
{OB_LATTICE, "LATTICE", 0, "Lattice", ""},
{0, NULL, 0, NULL, NULL}
};
@ -321,16 +321,16 @@ void OBJECT_OT_object_add(wmOperatorType *ot)
/* ****** work both in and outside editmode ****** */
static EnumPropertyItem prop_mesh_types[] = {
{0, "PLANE", "Plane", ""},
{1, "CUBE", "Cube", ""},
{2, "CIRCLE", "Circle", ""},
{3, "UVSPHERE", "UVsphere", ""},
{4, "ICOSPHERE", "Icosphere", ""},
{5, "CYLINDER", "Cylinder", ""},
{6, "CONE", "Cone", ""},
{7, "GRID", "Grid", ""},
{8, "MONKEY", "Monkey", ""},
{0, NULL, NULL, NULL}
{0, "PLANE", 0, "Plane", ""},
{1, "CUBE", 0, "Cube", ""},
{2, "CIRCLE", 0, "Circle", ""},
{3, "UVSPHERE", 0, "UVsphere", ""},
{4, "ICOSPHERE", 0, "Icosphere", ""},
{5, "CYLINDER", 0, "Cylinder", ""},
{6, "CONE", 0, "Cone", ""},
{7, "GRID", 0, "Grid", ""},
{8, "MONKEY", 0, "Monkey", ""},
{0, NULL, 0, NULL, NULL}
};
static int object_add_mesh_exec(bContext *C, wmOperator *op)
@ -405,12 +405,12 @@ void OBJECT_OT_mesh_add(wmOperatorType *ot)
}
static EnumPropertyItem prop_curve_types[] = {
{CU_BEZIER|CU_2D|CU_PRIM_CURVE, "BEZIER_CURVE", "Bezier Curve", ""},
{CU_BEZIER|CU_2D|CU_PRIM_CIRCLE, "BEZIER_CIRCLE", "Bezier Circle", ""},
{CU_NURBS|CU_2D|CU_PRIM_CURVE, "NURBS_CURVE", "NURBS Curve", ""},
{CU_NURBS|CU_2D|CU_PRIM_CIRCLE, "NURBS_CIRCLE", "NURBS Circle", ""},
{CU_NURBS|CU_2D|CU_PRIM_PATH, "PATH", "Path", ""},
{0, NULL, NULL, NULL}
{CU_BEZIER|CU_2D|CU_PRIM_CURVE, "BEZIER_CURVE", 0, "Bezier Curve", ""},
{CU_BEZIER|CU_2D|CU_PRIM_CIRCLE, "BEZIER_CIRCLE", 0, "Bezier Circle", ""},
{CU_NURBS|CU_2D|CU_PRIM_CURVE, "NURBS_CURVE", 0, "NURBS Curve", ""},
{CU_NURBS|CU_2D|CU_PRIM_CIRCLE, "NURBS_CIRCLE", 0, "NURBS Circle", ""},
{CU_NURBS|CU_2D|CU_PRIM_PATH, "PATH", 0, "Path", ""},
{0, NULL, 0, NULL, NULL}
};
static int object_add_curve_exec(bContext *C, wmOperator *op)
@ -479,13 +479,13 @@ void OBJECT_OT_curve_add(wmOperatorType *ot)
}
static EnumPropertyItem prop_surface_types[]= {
{CU_PRIM_CURVE|CU_NURBS, "NURBS_CURVE", "NURBS Curve", ""},
{CU_PRIM_CIRCLE|CU_NURBS, "NURBS_CIRCLE", "NURBS Circle", ""},
{CU_PRIM_PATCH|CU_NURBS, "NURBS_SURFACE", "NURBS Surface", ""},
{CU_PRIM_TUBE|CU_NURBS, "NURBS_TUBE", "NURBS Tube", ""},
{CU_PRIM_SPHERE|CU_NURBS, "NURBS_SPHERE", "NURBS Sphere", ""},
{CU_PRIM_DONUT|CU_NURBS, "NURBS_DONUT", "NURBS Donut", ""},
{0, NULL, NULL, NULL}
{CU_PRIM_CURVE|CU_NURBS, "NURBS_CURVE", 0, "NURBS Curve", ""},
{CU_PRIM_CIRCLE|CU_NURBS, "NURBS_CIRCLE", 0, "NURBS Circle", ""},
{CU_PRIM_PATCH|CU_NURBS, "NURBS_SURFACE", 0, "NURBS Surface", ""},
{CU_PRIM_TUBE|CU_NURBS, "NURBS_TUBE", 0, "NURBS Tube", ""},
{CU_PRIM_SPHERE|CU_NURBS, "NURBS_SPHERE", 0, "NURBS Sphere", ""},
{CU_PRIM_DONUT|CU_NURBS, "NURBS_DONUT", 0, "NURBS Donut", ""},
{0, NULL, 0, NULL, NULL}
};
static int object_add_surface_exec(bContext *C, wmOperator *op)
@ -1366,10 +1366,10 @@ void add_hook_menu(Scene *scene, View3D *v3d)
/* ******************** clear parent operator ******************* */
static EnumPropertyItem prop_clear_parent_types[] = {
{0, "CLEAR", "Clear Parent", ""},
{1, "CLEAR_KEEP_TRANSFORM", "Clear and Keep Transformation (Clear Track)", ""},
{2, "CLEAR_INVERSE", "Clear Parent Inverse", ""},
{0, NULL, NULL, NULL}
{0, "CLEAR", 0, "Clear Parent", ""},
{1, "CLEAR_KEEP_TRANSFORM", 0, "Clear and Keep Transformation (Clear Track)", ""},
{2, "CLEAR_INVERSE", 0, "Clear Parent Inverse", ""},
{0, NULL, 0, NULL, NULL}
};
/* note, poll should check for editable scene */
@ -1422,9 +1422,9 @@ void OBJECT_OT_parent_clear(wmOperatorType *ot)
static EnumPropertyItem prop_clear_track_types[] = {
{0, "CLEAR", "Clear Track", ""},
{1, "CLEAR_KEEP_TRANSFORM", "Clear and Keep Transformation (Clear Track)", ""},
{0, NULL, NULL, NULL}
{0, "CLEAR", 0, "Clear Track", ""},
{1, "CLEAR_KEEP_TRANSFORM", 0, "Clear and Keep Transformation (Clear Track)", ""},
{0, NULL, 0, NULL, NULL}
};
/* note, poll should check for editable scene */
@ -1471,9 +1471,9 @@ void OBJECT_OT_track_clear(wmOperatorType *ot)
/* *****************Selection Operators******************* */
static EnumPropertyItem prop_select_types[] = {
{0, "EXCLUSIVE", "Exclusive", ""},
{1, "EXTEND", "Extend", ""},
{0, NULL, NULL, NULL}
{0, "EXCLUSIVE", 0, "Exclusive", ""},
{1, "EXTEND", 0, "Extend", ""},
{0, NULL, 0, NULL, NULL}
};
/* ****** Select by Type ****** */
@ -1526,13 +1526,13 @@ void OBJECT_OT_select_by_type(wmOperatorType *ot)
/* ****** selection by links *******/
static EnumPropertyItem prop_select_linked_types[] = {
{1, "IPO", "Object IPO", ""}, // XXX depreceated animation system stuff...
{2, "OBDATA", "Ob Data", ""},
{3, "MATERIAL", "Material", ""},
{4, "TEXTURE", "Texture", ""},
{5, "DUPGROUP", "Dupligroup", ""},
{6, "PARTICLE", "Particle System", ""},
{0, NULL, NULL, NULL}
{1, "IPO", 0, "Object IPO", ""}, // XXX depreceated animation system stuff...
{2, "OBDATA", 0, "Ob Data", ""},
{3, "MATERIAL", 0, "Material", ""},
{4, "TEXTURE", 0, "Texture", ""},
{5, "DUPGROUP", 0, "Dupligroup", ""},
{6, "PARTICLE", 0, "Particle System", ""},
{0, NULL, 0, NULL, NULL}
};
static int object_select_linked_exec(bContext *C, wmOperator *op)
@ -2085,9 +2085,9 @@ void OBJECT_OT_restrictview_clear(wmOperatorType *ot)
}
static EnumPropertyItem prop_set_restrictview_types[] = {
{0, "SELECTED", "Selected", ""},
{1, "UNSELECTED", "Unselected ", ""},
{0, NULL, NULL, NULL}
{0, "SELECTED", 0, "Selected", ""},
{1, "UNSELECTED", 0, "Unselected ", ""},
{0, NULL, 0, NULL, NULL}
};
static int object_restrictview_set_exec(bContext *C, wmOperator *op)
@ -2462,16 +2462,16 @@ void make_proxy(Scene *scene)
#define PAR_TRIA 8
static EnumPropertyItem prop_make_parent_types[] = {
{PAR_OBJECT, "OBJECT", "Object", ""},
{PAR_ARMATURE, "ARMATURE", "Armature Deform", ""},
{PAR_BONE, "BONE", "Bone", ""},
{PAR_CURVE, "CURVE", "Curve Deform", ""},
{PAR_FOLLOW, "FOLLOW", "Follow Path", ""},
{PAR_PATH_CONST, "PATH_CONST", "Path Constraint", ""},
{PAR_LATTICE, "LATTICE", "Lattice Deform", ""},
{PAR_VERTEX, "VERTEX", "Vertex", ""},
{PAR_TRIA, "TRIA", "Triangle", ""},
{0, NULL, NULL, NULL}
{PAR_OBJECT, "OBJECT", 0, "Object", ""},
{PAR_ARMATURE, "ARMATURE", 0, "Armature Deform", ""},
{PAR_BONE, "BONE", 0, "Bone", ""},
{PAR_CURVE, "CURVE", 0, "Curve Deform", ""},
{PAR_FOLLOW, "FOLLOW", 0, "Follow Path", ""},
{PAR_PATH_CONST, "PATH_CONST", 0, "Path Constraint", ""},
{PAR_LATTICE, "LATTICE", 0, "Lattice Deform", ""},
{PAR_VERTEX, "VERTEX", 0, "Vertex", ""},
{PAR_TRIA, "TRIA", 0, "Triangle", ""},
{0, NULL, 0, NULL, NULL}
};
static int test_parent_loop(Object *par, Object *ob)
@ -2655,10 +2655,10 @@ void OBJECT_OT_parent_set(wmOperatorType *ot)
/* *** make track ***** */
static EnumPropertyItem prop_make_track_types[] = {
{1, "TRACKTO", "TrackTo Constraint", ""},
{2, "LOCKTRACK", "LockTrack Constraint", ""},
{3, "OLDTRACK", "Old Track", ""},
{0, NULL, NULL, NULL}
{1, "TRACKTO", 0, "TrackTo Constraint", ""},
{2, "LOCKTRACK", 0, "LockTrack Constraint", ""},
{3, "OLDTRACK", 0, "Old Track", ""},
{0, NULL, 0, NULL, NULL}
};
static int track_set_exec(bContext *C, wmOperator *op)
@ -2831,10 +2831,10 @@ void OBJECT_OT_dupli_set_real(wmOperatorType *ot)
/* ******************* Set Object Center ********************** */
static EnumPropertyItem prop_set_center_types[] = {
{0, "CENTER", "ObData to Center", "Move object data around Object center"},
{1, "CENTERNEW", "Center New", "Move Object center to center of object data"},
{2, "CENTERCURSOR", "Center Cursor", "Move Object Center to position of the 3d cursor"},
{0, NULL, NULL, NULL}
{0, "CENTER", 0, "ObData to Center", "Move object data around Object center"},
{1, "CENTERNEW", 0, "Center New", "Move Object center to center of object data"},
{2, "CENTERCURSOR", 0, "Center Cursor", "Move Object Center to position of the 3d cursor"},
{0, NULL, 0, NULL, NULL}
};
/* 0 == do center, 1 == center new, 2 == center cursor */

22
source/blender/editors/physics/editparticle.c
View File

@ -2347,8 +2347,8 @@ void PARTICLE_OT_brush_radial_control(wmOperatorType *ot)
enum { DEL_PARTICLE, DEL_KEY };
static EnumPropertyItem delete_type_items[]= {
{DEL_PARTICLE, "PARTICLE", "Particle", ""},
{DEL_KEY, "KEY", "Key", ""},
{DEL_PARTICLE, "PARTICLE", 0, "Particle", ""},
{DEL_KEY, "KEY", 0, "Key", ""},
{0, NULL, NULL}};
static void set_delete_particle(PEData *data, int pa_index)
@ -2563,15 +2563,15 @@ void PARTICLE_OT_mirror(wmOperatorType *ot)
/*********************** set brush operator **********************/
static EnumPropertyItem brush_type_items[]= {
{PE_BRUSH_NONE, "NONE", "None", ""},
{PE_BRUSH_COMB, "COMB", "Comb", ""},
{PE_BRUSH_SMOOTH, "SMOOTH", "Smooth", ""},
{PE_BRUSH_WEIGHT, "WEIGHT", "Weight", ""},
{PE_BRUSH_ADD, "ADD", "Add", ""},
{PE_BRUSH_LENGTH, "LENGTH", "Length", ""},
{PE_BRUSH_PUFF, "PUFF", "Puff", ""},
{PE_BRUSH_CUT, "CUT", "Cut", ""},
{0, NULL, NULL, NULL}
{PE_BRUSH_NONE, "NONE", 0, "None", ""},
{PE_BRUSH_COMB, "COMB", 0, "Comb", ""},
{PE_BRUSH_SMOOTH, "SMOOTH", 0, "Smooth", ""},
{PE_BRUSH_WEIGHT, "WEIGHT", 0, "Weight", ""},
{PE_BRUSH_ADD, "ADD", 0, "Add", ""},
{PE_BRUSH_LENGTH, "LENGTH", 0, "Length", ""},
{PE_BRUSH_PUFF, "PUFF", 0, "Puff", ""},
{PE_BRUSH_CUT, "CUT", 0, "Cut", ""},
{0, NULL, 0, NULL, NULL}
};
static int set_brush_exec(bContext *C, wmOperator *op)

6
source/blender/editors/screen/screen_ops.c
View File

@ -1192,9 +1192,9 @@ static int area_split_modal(bContext *C, wmOperator *op, wmEvent *event)
}
static EnumPropertyItem prop_direction_items[] = {
{'h', "HORIZONTAL", "Horizontal", ""},
{'v', "VERTICAL", "Vertical", ""},
{0, NULL, NULL, NULL}};
{'h', "HORIZONTAL", 0, "Horizontal", ""},
{'v', "VERTICAL", 0, "Vertical", ""},
{0, NULL, 0, NULL, NULL}};
void SCREEN_OT_area_split(wmOperatorType *ot)
{

8
source/blender/editors/sculpt_paint/sculpt.c
View File

@ -1245,10 +1245,10 @@ static int sculpt_brush_curve_preset_exec(bContext *C, wmOperator *op)
static void SCULPT_OT_brush_curve_preset(wmOperatorType *ot)
{
static EnumPropertyItem prop_mode_items[] = {
{BRUSH_PRESET_SHARP, "SHARP", "Sharp Curve", ""},
{BRUSH_PRESET_SMOOTH, "SMOOTH", "Smooth Curve", ""},
{BRUSH_PRESET_MAX, "MAX", "Max Curve", ""},
{0, NULL, NULL, NULL}};
{BRUSH_PRESET_SHARP, "SHARP", 0, "Sharp Curve", ""},
{BRUSH_PRESET_SMOOTH, "SMOOTH", 0, "Smooth Curve", ""},
{BRUSH_PRESET_MAX, "MAX", 0, "Max Curve", ""},
{0, NULL, 0, NULL, NULL}};
ot->name= "Preset";
ot->idname= "SCULPT_OT_brush_curve_preset";

34
source/blender/editors/space_action/action_edit.c
View File

@ -369,10 +369,10 @@ void ACT_OT_keyframes_paste (wmOperatorType *ot)
/* defines for insert keyframes tool */
EnumPropertyItem prop_actkeys_insertkey_types[] = {
{1, "ALL", "All Channels", ""},
{2, "SEL", "Only Selected Channels", ""},
{3, "GROUP", "In Active Group", ""}, // xxx not in all cases
{0, NULL, NULL, NULL}
{1, "ALL", 0, "All Channels", ""},
{2, "SEL", 0, "Only Selected Channels", ""},
{3, "GROUP", 0, "In Active Group", ""}, // xxx not in all cases
{0, NULL, 0, NULL, NULL}
};
/* this function is responsible for snapping keyframes to frame-times */
@ -799,9 +799,9 @@ void ACT_OT_keyframes_sample (wmOperatorType *ot)
/* defines for set extrapolation-type for selected keyframes tool */
EnumPropertyItem prop_actkeys_expo_types[] = {
{FCURVE_EXTRAPOLATE_CONSTANT, "CONSTANT", "Constant Extrapolation", ""},
{FCURVE_EXTRAPOLATE_LINEAR, "LINEAR", "Linear Extrapolation", ""},
{0, NULL, NULL, NULL}
{FCURVE_EXTRAPOLATE_CONSTANT, "CONSTANT", 0, "Constant Extrapolation", ""},
{FCURVE_EXTRAPOLATE_LINEAR, "LINEAR", 0, "Linear Extrapolation", ""},
{0, NULL, 0, NULL, NULL}
};
/* this function is responsible for setting extrapolation mode for keyframes */
@ -1089,11 +1089,11 @@ void ACT_OT_keyframes_cfrasnap (wmOperatorType *ot)
/* defines for snap keyframes tool */
EnumPropertyItem prop_actkeys_snap_types[] = {
{ACTKEYS_SNAP_CFRA, "CFRA", "Current frame", ""},
{ACTKEYS_SNAP_NEAREST_FRAME, "NEAREST_FRAME", "Nearest Frame", ""}, // XXX as single entry?
{ACTKEYS_SNAP_NEAREST_SECOND, "NEAREST_SECOND", "Nearest Second", ""}, // XXX as single entry?
{ACTKEYS_SNAP_NEAREST_MARKER, "NEAREST_MARKER", "Nearest Marker", ""},
{0, NULL, NULL, NULL}
{ACTKEYS_SNAP_CFRA, "CFRA", 0, "Current frame", ""},
{ACTKEYS_SNAP_NEAREST_FRAME, "NEAREST_FRAME", 0, "Nearest Frame", ""}, // XXX as single entry?
{ACTKEYS_SNAP_NEAREST_SECOND, "NEAREST_SECOND", 0, "Nearest Second", ""}, // XXX as single entry?
{ACTKEYS_SNAP_NEAREST_MARKER, "NEAREST_MARKER", 0, "Nearest Marker", ""},
{0, NULL, 0, NULL, NULL}
};
/* this function is responsible for snapping keyframes to frame-times */
@ -1188,11 +1188,11 @@ void ACT_OT_keyframes_snap (wmOperatorType *ot)
/* defines for mirror keyframes tool */
EnumPropertyItem prop_actkeys_mirror_types[] = {
{ACTKEYS_MIRROR_CFRA, "CFRA", "Current frame", ""},
{ACTKEYS_MIRROR_YAXIS, "YAXIS", "Vertical Axis", ""},
{ACTKEYS_MIRROR_XAXIS, "XAXIS", "Horizontal Axis", ""},
{ACTKEYS_MIRROR_MARKER, "MARKER", "First Selected Marker", ""},
{0, NULL, NULL, NULL}
{ACTKEYS_MIRROR_CFRA, "CFRA", 0, "Current frame", ""},
{ACTKEYS_MIRROR_YAXIS, "YAXIS", 0, "Vertical Axis", ""},
{ACTKEYS_MIRROR_XAXIS, "XAXIS", 0, "Horizontal Axis", ""},
{ACTKEYS_MIRROR_MARKER, "MARKER", 0, "First Selected Marker", ""},
{0, NULL, 0, NULL, NULL}
};
/* this function is responsible for mirroring keyframes */

20
source/blender/editors/space_action/action_select.c
View File

@ -374,11 +374,11 @@ void ACT_OT_keyframes_select_border(wmOperatorType *ot)
/* defines for column-select mode */
static EnumPropertyItem prop_column_select_types[] = {
{ACTKEYS_COLUMNSEL_KEYS, "KEYS", "On Selected Keyframes", ""},
{ACTKEYS_COLUMNSEL_CFRA, "CFRA", "On Current Frame", ""},
{ACTKEYS_COLUMNSEL_MARKERS_COLUMN, "MARKERS_COLUMN", "On Selected Markers", ""},
{ACTKEYS_COLUMNSEL_MARKERS_BETWEEN, "MARKERS_BETWEEN", "Between Min/Max Selected Markers", ""},
{0, NULL, NULL, NULL}
{ACTKEYS_COLUMNSEL_KEYS, "KEYS", 0, "On Selected Keyframes", ""},
{ACTKEYS_COLUMNSEL_CFRA, "CFRA", 0, "On Current Frame", ""},
{ACTKEYS_COLUMNSEL_MARKERS_COLUMN, "MARKERS_COLUMN", 0, "On Selected Markers", ""},
{ACTKEYS_COLUMNSEL_MARKERS_BETWEEN, "MARKERS_BETWEEN", 0, "Between Min/Max Selected Markers", ""},
{0, NULL, 0, NULL, NULL}
};
/* ------------------- */
@ -584,11 +584,11 @@ void ACT_OT_keyframes_select_column (wmOperatorType *ot)
/* defines for left-right select tool */
static EnumPropertyItem prop_actkeys_leftright_select_types[] = {
{ACTKEYS_LRSEL_TEST, "CHECK", "Check if Select Left or Right", ""},
{ACTKEYS_LRSEL_NONE, "OFF", "Don't select", ""},
{ACTKEYS_LRSEL_LEFT, "LEFT", "Before current frame", ""},
{ACTKEYS_LRSEL_RIGHT, "RIGHT", "After current frame", ""},
{0, NULL, NULL, NULL}
{ACTKEYS_LRSEL_TEST, "CHECK", 0, "Check if Select Left or Right", ""},
{ACTKEYS_LRSEL_NONE, "OFF", 0, "Don't select", ""},
{ACTKEYS_LRSEL_LEFT, "LEFT", 0, "Before current frame", ""},
{ACTKEYS_LRSEL_RIGHT, "RIGHT", 0, "After current frame", ""},
{0, NULL, 0, NULL, NULL}
};
/* sensitivity factor for frame-selections */

28
source/blender/editors/space_graph/graph_edit.c
View File

@ -1001,9 +1001,9 @@ void GRAPHEDIT_OT_keyframes_sample (wmOperatorType *ot)
/* defines for set extrapolation-type for selected keyframes tool */
EnumPropertyItem prop_graphkeys_expo_types[] = {
{FCURVE_EXTRAPOLATE_CONSTANT, "CONSTANT", "Constant Extrapolation", ""},
{FCURVE_EXTRAPOLATE_LINEAR, "LINEAR", "Linear Extrapolation", ""},
{0, NULL, NULL, NULL}
{FCURVE_EXTRAPOLATE_CONSTANT, "CONSTANT", 0, "Constant Extrapolation", ""},
{FCURVE_EXTRAPOLATE_LINEAR, "LINEAR", 0, "Linear Extrapolation", ""},
{0, NULL, 0, NULL, NULL}
};
/* this function is responsible for setting extrapolation mode for keyframes */
@ -1371,12 +1371,12 @@ void GRAPHEDIT_OT_keyframes_cfrasnap (wmOperatorType *ot)
/* defines for snap keyframes tool */
EnumPropertyItem prop_graphkeys_snap_types[] = {
{GRAPHKEYS_SNAP_CFRA, "CFRA", "Current frame", ""},
{GRAPHKEYS_SNAP_NEAREST_FRAME, "NEAREST_FRAME", "Nearest Frame", ""}, // XXX as single entry?
{GRAPHKEYS_SNAP_NEAREST_SECOND, "NEAREST_SECOND", "Nearest Second", ""}, // XXX as single entry?
{GRAPHKEYS_SNAP_NEAREST_MARKER, "NEAREST_MARKER", "Nearest Marker", ""},
{GRAPHKEYS_SNAP_HORIZONTAL, "HORIZONTAL", "Flatten Handles", ""},
{0, NULL, NULL, NULL}
{GRAPHKEYS_SNAP_CFRA, "CFRA", 0, "Current frame", ""},
{GRAPHKEYS_SNAP_NEAREST_FRAME, "NEAREST_FRAME", 0, "Nearest Frame", ""}, // XXX as single entry?
{GRAPHKEYS_SNAP_NEAREST_SECOND, "NEAREST_SECOND", 0, "Nearest Second", ""}, // XXX as single entry?
{GRAPHKEYS_SNAP_NEAREST_MARKER, "NEAREST_MARKER", 0, "Nearest Marker", ""},
{GRAPHKEYS_SNAP_HORIZONTAL, "HORIZONTAL", 0, "Flatten Handles", ""},
{0, NULL, 0, NULL, NULL}
};
/* this function is responsible for snapping keyframes to frame-times */
@ -1466,11 +1466,11 @@ void GRAPHEDIT_OT_keyframes_snap (wmOperatorType *ot)
/* defines for mirror keyframes tool */
EnumPropertyItem prop_graphkeys_mirror_types[] = {
{GRAPHKEYS_MIRROR_CFRA, "CFRA", "Current frame", ""},
{GRAPHKEYS_MIRROR_YAXIS, "YAXIS", "Vertical Axis", ""},
{GRAPHKEYS_MIRROR_XAXIS, "XAXIS", "Horizontal Axis", ""},
{GRAPHKEYS_MIRROR_MARKER, "MARKER", "First Selected Marker", ""},
{0, NULL, NULL, NULL}
{GRAPHKEYS_MIRROR_CFRA, "CFRA", 0, "Current frame", ""},
{GRAPHKEYS_MIRROR_YAXIS, "YAXIS", 0, "Vertical Axis", ""},
{GRAPHKEYS_MIRROR_XAXIS, "XAXIS", 0, "Horizontal Axis", ""},
{GRAPHKEYS_MIRROR_MARKER, "MARKER", 0, "First Selected Marker", ""},
{0, NULL, 0, NULL, NULL}
};
/* this function is responsible for mirroring keyframes */

20
source/blender/editors/space_graph/graph_select.c
View File

@ -340,11 +340,11 @@ void GRAPHEDIT_OT_keyframes_select_border(wmOperatorType *ot)
/* defines for column-select mode */
static EnumPropertyItem prop_column_select_types[] = {
{GRAPHKEYS_COLUMNSEL_KEYS, "KEYS", "On Selected Keyframes", ""},
{GRAPHKEYS_COLUMNSEL_CFRA, "CFRA", "On Current Frame", ""},
{GRAPHKEYS_COLUMNSEL_MARKERS_COLUMN, "MARKERS_COLUMN", "On Selected Markers", ""},
{GRAPHKEYS_COLUMNSEL_MARKERS_BETWEEN, "MARKERS_BETWEEN", "Between Min/Max Selected Markers", ""},
{0, NULL, NULL, NULL}
{GRAPHKEYS_COLUMNSEL_KEYS, "KEYS", 0, "On Selected Keyframes", ""},
{GRAPHKEYS_COLUMNSEL_CFRA, "CFRA", 0, "On Current Frame", ""},
{GRAPHKEYS_COLUMNSEL_MARKERS_COLUMN, "MARKERS_COLUMN", 0, "On Selected Markers", ""},
{GRAPHKEYS_COLUMNSEL_MARKERS_BETWEEN, "MARKERS_BETWEEN", 0, "Between Min/Max Selected Markers", ""},
{0, NULL, 0, NULL, NULL}
};
/* ------------------- */
@ -526,11 +526,11 @@ void GRAPHEDIT_OT_keyframes_columnselect (wmOperatorType *ot)
/* defines for left-right select tool */
static EnumPropertyItem prop_graphkeys_leftright_select_types[] = {
{GRAPHKEYS_LRSEL_TEST, "CHECK", "Check if Select Left or Right", ""},
{GRAPHKEYS_LRSEL_NONE, "OFF", "Don't select", ""},
{GRAPHKEYS_LRSEL_LEFT, "LEFT", "Before current frame", ""},
{GRAPHKEYS_LRSEL_RIGHT, "RIGHT", "After current frame", ""},
{0, NULL, NULL, NULL}
{GRAPHKEYS_LRSEL_TEST, "CHECK", 0, "Check if Select Left or Right", ""},
{GRAPHKEYS_LRSEL_NONE, "OFF", 0, "Don't select", ""},
{GRAPHKEYS_LRSEL_LEFT, "LEFT", 0, "Before current frame", ""},
{GRAPHKEYS_LRSEL_RIGHT, "RIGHT", 0, "After current frame", ""},
{0, NULL, 0, NULL, NULL}
};
/* ------------------- */

6
source/blender/editors/space_image/image_ops.c
View File

@ -1412,9 +1412,9 @@ void IMAGE_OT_sample(wmOperatorType *ot)
void IMAGE_OT_curves_point_set(wmOperatorType *ot)
{
static EnumPropertyItem point_items[]= {
{0, "BLACK_POINT", "Black Point", ""},
{1, "WHITE_POINT", "White Point", ""},
{0, NULL, NULL, NULL}};
{0, "BLACK_POINT", 0, "Black Point", ""},
{1, "WHITE_POINT", 0, "White Point", ""},
{0, NULL, 0, NULL, NULL}};
/* identifiers */
ot->name= "Set Curves Point";

10
source/blender/editors/space_node/node_select.c
View File

@ -177,8 +177,8 @@ static int node_extend_select_invoke(bContext *C, wmOperator *op, wmEvent *event
/* operators */
static EnumPropertyItem prop_select_items[] = {
{NODE_SELECT_MOUSE, "NORMAL", "Normal Select", "Select using the mouse"},
{0, NULL, NULL, NULL}};
{NODE_SELECT_MOUSE, "NORMAL", 0, "Normal Select", "Select using the mouse"},
{0, NULL, 0, NULL, NULL}};
void NODE_OT_select_extend(wmOperatorType *ot)
{
@ -225,9 +225,9 @@ void NODE_OT_select(wmOperatorType *ot)
/* ****** Border Select ****** */
static EnumPropertyItem prop_select_types[] = {
{NODE_EXCLUSIVE, "EXCLUSIVE", "Exclusive", ""}, /* right mouse */
{NODE_EXTEND, "EXTEND", "Extend", ""}, /* left mouse */
{0, NULL, NULL, NULL}
{NODE_EXCLUSIVE, "EXCLUSIVE", 0, "Exclusive", ""}, /* right mouse */
{NODE_EXTEND, "EXTEND", 0, "Extend", ""}, /* left mouse */
{0, NULL, 0, NULL, NULL}
};
static int node_borderselect_exec(bContext *C, wmOperator *op)

50
source/blender/editors/space_sequencer/sequencer_edit.c
View File

@ -105,35 +105,35 @@ static int okee() {return 0;}
/* XXX */
/* RNA Enums, used in multiple files */
EnumPropertyItem sequencer_prop_effect_types[] = {
{SEQ_CROSS, "CROSS", "Crossfade", "Crossfade effect strip type"},
{SEQ_ADD, "ADD", "Add", "Add effect strip type"},
{SEQ_SUB, "SUBTRACT", "Subtract", "Subtract effect strip type"},
{SEQ_ALPHAOVER, "ALPHA_OVER", "Alpha Over", "Alpha Over effect strip type"},
{SEQ_ALPHAUNDER, "ALPHA_UNDER", "Alpha Under", "Alpha Under effect strip type"},
{SEQ_GAMCROSS, "GAMMA_CROSS", "Gamma Cross", "Gamma Cross effect strip type"},
{SEQ_MUL, "MULTIPLY", "Multiply", "Multiply effect strip type"},
{SEQ_OVERDROP, "OVER_DROP", "Alpha Over Drop", "Alpha Over Drop effect strip type"},
{SEQ_PLUGIN, "PLUGIN", "Plugin", "Plugin effect strip type"},
{SEQ_WIPE, "WIPE", "Wipe", "Wipe effect strip type"},
{SEQ_GLOW, "GLOW", "Glow", "Glow effect strip type"},
{SEQ_TRANSFORM, "TRANSFORM", "Transform", "Transform effect strip type"},
{SEQ_COLOR, "COLOR", "Color", "Color effect strip type"},
{SEQ_SPEED, "SPEED", "Speed", "Color effect strip type"},
{0, NULL, NULL, NULL}
{SEQ_CROSS, "CROSS", 0, "Crossfade", "Crossfade effect strip type"},
{SEQ_ADD, "ADD", 0, "Add", "Add effect strip type"},
{SEQ_SUB, "SUBTRACT", 0, "Subtract", "Subtract effect strip type"},
{SEQ_ALPHAOVER, "ALPHA_OVER", 0, "Alpha Over", "Alpha Over effect strip type"},
{SEQ_ALPHAUNDER, "ALPHA_UNDER", 0, "Alpha Under", "Alpha Under effect strip type"},
{SEQ_GAMCROSS, "GAMMA_CROSS", 0, "Gamma Cross", "Gamma Cross effect strip type"},
{SEQ_MUL, "MULTIPLY", 0, "Multiply", "Multiply effect strip type"},
{SEQ_OVERDROP, "OVER_DROP", 0, "Alpha Over Drop", "Alpha Over Drop effect strip type"},
{SEQ_PLUGIN, "PLUGIN", 0, "Plugin", "Plugin effect strip type"},
{SEQ_WIPE, "WIPE", 0, "Wipe", "Wipe effect strip type"},
{SEQ_GLOW, "GLOW", 0, "Glow", "Glow effect strip type"},
{SEQ_TRANSFORM, "TRANSFORM", 0, "Transform", "Transform effect strip type"},
{SEQ_COLOR, "COLOR", 0, "Color", "Color effect strip type"},
{SEQ_SPEED, "SPEED", 0, "Speed", "Color effect strip type"},
{0, NULL, 0, NULL, NULL}
};
/* mute operator */
EnumPropertyItem sequencer_prop_operate_types[] = { /* better name? */
{SEQ_SELECTED, "SELECTED", "Selected", ""},
{SEQ_UNSELECTED, "UNSELECTED", "Unselected ", ""},
{0, NULL, NULL, NULL}
{SEQ_SELECTED, "SELECTED", 0, "Selected", ""},
{SEQ_UNSELECTED, "UNSELECTED", 0, "Unselected ", ""},
{0, NULL, 0, NULL, NULL}
};
EnumPropertyItem prop_side_types[] = {
{SEQ_SIDE_LEFT, "LEFT", "Left", ""},
{SEQ_SIDE_RIGHT, "RIGHT", "Right", ""},
{SEQ_SIDE_BOTH, "BOTH", "Both", ""},
{0, NULL, NULL, NULL}
{SEQ_SIDE_LEFT, "LEFT", 0, "Left", ""},
{SEQ_SIDE_RIGHT, "RIGHT", 0, "Right", ""},
{SEQ_SIDE_BOTH, "BOTH", 0, "Both", ""},
{0, NULL, 0, NULL, NULL}
};
typedef struct TransSeq {
@ -1726,9 +1726,9 @@ void SEQUENCER_OT_refresh_all(struct wmOperatorType *ot)
/* cut operator */
static EnumPropertyItem prop_cut_types[] = {
{SEQ_CUT_SOFT, "SOFT", "Soft", ""},
{SEQ_CUT_HARD, "HARD", "Hard", ""},
{0, NULL, NULL, NULL}
{SEQ_CUT_SOFT, "SOFT", 0, "Soft", ""},
{SEQ_CUT_HARD, "HARD", 0, "Hard", ""},
{0, NULL, 0, NULL, NULL}
};
static int sequencer_cut_exec(bContext *C, wmOperator *op)

52
source/blender/editors/space_text/text_ops.c
View File

@ -972,9 +972,9 @@ void TEXT_OT_uncomment(wmOperatorType *ot)
enum { TO_SPACES, TO_TABS };
static EnumPropertyItem whitespace_type_items[]= {
{TO_SPACES, "SPACES", "To Spaces", NULL},
{TO_TABS, "TABS", "To Tabs", NULL},
{0, NULL, NULL, NULL}};
{TO_SPACES, "SPACES", 0, "To Spaces", NULL},
{TO_TABS, "TABS", 0, "To Tabs", NULL},
{0, NULL, 0, NULL, NULL}};
static int convert_whitespace_exec(bContext *C, wmOperator *op)
{
@ -1270,19 +1270,19 @@ void TEXT_OT_markers_clear(wmOperatorType *ot)
/************************ move operator ************************/
static EnumPropertyItem move_type_items[]= {
{LINE_BEGIN, "LINE_BEGIN", "Line Begin", ""},
{LINE_END, "LINE_END", "Line End", ""},
{FILE_TOP, "FILE_TOP", "File Top", ""},
{FILE_BOTTOM, "FILE_BOTTOM", "File Bottom", ""},
{PREV_CHAR, "PREVIOUS_CHARACTER", "Previous Character", ""},
{NEXT_CHAR, "NEXT_CHARACTER", "Next Character", ""},
{PREV_WORD, "PREVIOUS_WORD", "Previous Word", ""},
{NEXT_WORD, "NEXT_WORD", "Next Word", ""},
{PREV_LINE, "PREVIOUS_LINE", "Previous Line", ""},
{NEXT_LINE, "NEXT_LINE", "Next Line", ""},
{PREV_PAGE, "PREVIOUS_PAGE", "Previous Page", ""},
{NEXT_PAGE, "NEXT_PAGE", "Next Page", ""},
{0, NULL, NULL, NULL}};
{LINE_BEGIN, "LINE_BEGIN", 0, "Line Begin", ""},
{LINE_END, "LINE_END", 0, "Line End", ""},
{FILE_TOP, "FILE_TOP", 0, "File Top", ""},
{FILE_BOTTOM, "FILE_BOTTOM", 0, "File Bottom", ""},
{PREV_CHAR, "PREVIOUS_CHARACTER", 0, "Previous Character", ""},
{NEXT_CHAR, "NEXT_CHARACTER", 0, "Next Character", ""},
{PREV_WORD, "PREVIOUS_WORD", 0, "Previous Word", ""},
{NEXT_WORD, "NEXT_WORD", 0, "Next Word", ""},
{PREV_LINE, "PREVIOUS_LINE", 0, "Previous Line", ""},
{NEXT_LINE, "NEXT_LINE", 0, "Next Line", ""},
{PREV_PAGE, "PREVIOUS_PAGE", 0, "Previous Page", ""},
{NEXT_PAGE, "NEXT_PAGE", 0, "Next Page", ""},
{0, NULL, 0, NULL, NULL}};
static void wrap_move_bol(SpaceText *st, ARegion *ar, short sel)
{
@ -1613,11 +1613,11 @@ void TEXT_OT_jump(wmOperatorType *ot)
/******************* delete operator **********************/
static EnumPropertyItem delete_type_items[]= {
{DEL_NEXT_CHAR, "NEXT_CHARACTER", "Next Character", ""},
{DEL_PREV_CHAR, "PREVIOUS_CHARACTER", "Previous Character", ""},
{DEL_NEXT_WORD, "NEXT_WORD", "Next Word", ""},
{DEL_PREV_WORD, "PREVIOUS_WORD", "Previous Word", ""},
{0, NULL, NULL, NULL}};
{DEL_NEXT_CHAR, "NEXT_CHARACTER", 0, "Next Character", ""},
{DEL_PREV_CHAR, "PREVIOUS_CHARACTER", 0, "Previous Character", ""},
{DEL_NEXT_WORD, "NEXT_WORD", 0, "Next Word", ""},
{DEL_PREV_WORD, "PREVIOUS_WORD", 0, "Previous Word", ""},
{0, NULL, 0, NULL, NULL}};
static int delete_exec(bContext *C, wmOperator *op)
{
@ -2469,11 +2469,11 @@ void TEXT_OT_replace_set_selected(wmOperatorType *ot)
enum { RESOLVE_IGNORE, RESOLVE_RELOAD, RESOLVE_SAVE, RESOLVE_MAKE_INTERNAL };
static EnumPropertyItem resolution_items[]= {
{RESOLVE_IGNORE, "IGNORE", "Ignore", ""},
{RESOLVE_RELOAD, "RELOAD", "Reload", ""},
{RESOLVE_SAVE, "SAVE", "Save", ""},
{RESOLVE_MAKE_INTERNAL, "MAKE_INTERNAL", "Make Internal", ""},
{0, NULL, NULL, NULL}};
{RESOLVE_IGNORE, "IGNORE", 0, "Ignore", ""},
{RESOLVE_RELOAD, "RELOAD", 0, "Reload", ""},
{RESOLVE_SAVE, "SAVE", 0, "Save", ""},
{RESOLVE_MAKE_INTERNAL, "MAKE_INTERNAL", 0, "Make Internal", ""},
{0, NULL, 0, NULL, NULL}};
/* returns 0 if file on disk is the same or Text is in memory only
returns 1 if file has been modified on disk since last local edit

36
source/blender/editors/space_view3d/view3d_edit.c
View File

@ -1320,14 +1320,14 @@ void VIEW3D_OT_zoom_border(wmOperatorType *ot)
/* ********************* Changing view operator ****************** */
static EnumPropertyItem prop_view_items[] = {
{V3D_VIEW_FRONT, "FRONT", "Front", "View From the Front"},
{V3D_VIEW_BACK, "BACK", "Back", "View From the Back"},
{V3D_VIEW_LEFT, "LEFT", "Left", "View From the Left"},
{V3D_VIEW_RIGHT, "RIGHT", "Right", "View From the Right"},
{V3D_VIEW_TOP, "TOP", "Top", "View From the Top"},
{V3D_VIEW_BOTTOM, "BOTTOM", "Bottom", "View From the Bottom"},
{V3D_VIEW_CAMERA, "CAMERA", "Camera", "View From the active amera"},
{0, NULL, NULL, NULL}};
{V3D_VIEW_FRONT, "FRONT", 0, "Front", "View From the Front"},
{V3D_VIEW_BACK, "BACK", 0, "Back", "View From the Back"},
{V3D_VIEW_LEFT, "LEFT", 0, "Left", "View From the Left"},
{V3D_VIEW_RIGHT, "RIGHT", 0, "Right", "View From the Right"},
{V3D_VIEW_TOP, "TOP", 0, "Top", "View From the Top"},
{V3D_VIEW_BOTTOM, "BOTTOM", 0, "Bottom", "View From the Bottom"},
{V3D_VIEW_CAMERA, "CAMERA", 0, "Camera", "View From the active amera"},
{0, NULL, 0, NULL, NULL}};
static void axis_set_view(bContext *C, float q1, float q2, float q3, float q4, short view, int perspo)
{
@ -1479,11 +1479,11 @@ void VIEW3D_OT_viewnumpad(wmOperatorType *ot)
}
static EnumPropertyItem prop_view_orbit_items[] = {
{V3D_VIEW_STEPLEFT, "ORBITLEFT", "Orbit Left", "Orbit the view around to the Left"},
{V3D_VIEW_STEPRIGHT, "ORBITRIGHT", "Orbit Right", "Orbit the view around to the Right"},
{V3D_VIEW_STEPUP, "ORBITUP", "Orbit Up", "Orbit the view Up"},
{V3D_VIEW_STEPDOWN, "ORBITDOWN", "Orbit Down", "Orbit the view Down"},
{0, NULL, NULL, NULL}};
{V3D_VIEW_STEPLEFT, "ORBITLEFT", 0, "Orbit Left", "Orbit the view around to the Left"},
{V3D_VIEW_STEPRIGHT, "ORBITRIGHT", 0, "Orbit Right", "Orbit the view around to the Right"},
{V3D_VIEW_STEPUP, "ORBITUP", 0, "Orbit Up", "Orbit the view Up"},
{V3D_VIEW_STEPDOWN, "ORBITDOWN", 0, "Orbit Down", "Orbit the view Down"},
{0, NULL, 0, NULL, NULL}};
static int vieworbit_exec(bContext *C, wmOperator *op)
{
@ -1547,11 +1547,11 @@ void VIEW3D_OT_view_orbit(wmOperatorType *ot)
}
static EnumPropertyItem prop_view_pan_items[] = {
{V3D_VIEW_PANLEFT, "PANLEFT", "Pan Left", "Pan the view to the Left"},
{V3D_VIEW_PANRIGHT, "PANRIGHT", "Pan Right", "Pan the view to the Right"},
{V3D_VIEW_PANUP, "PANUP", "Pan Up", "Pan the view Up"},
{V3D_VIEW_PANDOWN, "PANDOWN", "Pan Down", "Pan the view Down"},
{0, NULL, NULL, NULL}};
{V3D_VIEW_PANLEFT, "PANLEFT", 0, "Pan Left", "Pan the view to the Left"},
{V3D_VIEW_PANRIGHT, "PANRIGHT", 0, "Pan Right", "Pan the view to the Right"},
{V3D_VIEW_PANUP, "PANUP", 0, "Pan Up", "Pan the view Up"},
{V3D_VIEW_PANDOWN, "PANDOWN", 0, "Pan Down", "Pan the view Down"},
{0, NULL, 0, NULL, NULL}};
static int viewpan_exec(bContext *C, wmOperator *op)
{

12
source/blender/editors/space_view3d/view3d_select.c
View File

@ -715,9 +715,9 @@ void view3d_lasso_select(bContext *C, ViewContext *vc, short mcords[][2], short
}
static EnumPropertyItem lasso_select_types[] = {
{0, "SELECT", "Select", ""},
{1, "DESELECT", "Deselect", ""},
{0, NULL, NULL, NULL}
{0, "SELECT", 0, "Select", ""},
{1, "DESELECT", 0, "Deselect", ""},
{0, NULL, 0, NULL, NULL}
};
@ -1526,9 +1526,9 @@ static int view3d_borderselect_exec(bContext *C, wmOperator *op)
/* *****************Selection Operators******************* */
static EnumPropertyItem prop_select_types[] = {
{0, "EXCLUSIVE", "Exclusive", ""},
{1, "EXTEND", "Extend", ""},
{0, NULL, NULL, NULL}
{0, "EXCLUSIVE", 0, "Exclusive", ""},
{1, "EXTEND", 0, "Extend", ""},
{0, NULL, 0, NULL, NULL}
};
/* ****** Border Select ****** */

100
source/blender/editors/transform/transform_ops.c
View File

@ -56,29 +56,29 @@ static float VecOne[3] = {1, 1, 1};
/* need constants for this */
EnumPropertyItem proportional_mode_types[] = {
{0, "OFF", "Off", ""},
{1, "ON", "On", ""},
{2, "CONNECTED", "Connected", ""},
{0, NULL, NULL, NULL}
{0, "OFF", 0, "Off", ""},
{1, "ON", 0, "On", ""},
{2, "CONNECTED", 0, "Connected", ""},
{0, NULL, 0, NULL, NULL}
};
EnumPropertyItem snap_mode_types[] = {
{SCE_SNAP_TARGET_CLOSEST, "CLOSEST", "Closest", ""},
{SCE_SNAP_TARGET_CENTER, "CENTER", "Center", ""},
{SCE_SNAP_TARGET_MEDIAN, "MEDIAN", "Median", ""},
{SCE_SNAP_TARGET_ACTIVE, "ACTIVE", "Active", ""},
{0, NULL, NULL, NULL}
{SCE_SNAP_TARGET_CLOSEST, "CLOSEST", 0, "Closest", ""},
{SCE_SNAP_TARGET_CENTER, "CENTER", 0, "Center", ""},
{SCE_SNAP_TARGET_MEDIAN, "MEDIAN", 0, "Median", ""},
{SCE_SNAP_TARGET_ACTIVE, "ACTIVE", 0, "Active", ""},
{0, NULL, 0, NULL, NULL}
};
EnumPropertyItem proportional_falloff_types[] = {
{PROP_SMOOTH, "SMOOTH", "Smooth", ""},
{PROP_SPHERE, "SPHERE", "Sphere", ""},
{PROP_ROOT, "ROOT", "Root", ""},
{PROP_SHARP, "SHARP", "Sharp", ""},
{PROP_LIN, "LINEAR", "Linear", ""},
{PROP_CONST, "CONSTANT", "Constant", ""},
{PROP_RANDOM, "RANDOM", "Random", ""},
{0, NULL, NULL, NULL}
{PROP_SMOOTH, "SMOOTH", 0, "Smooth", ""},
{PROP_SPHERE, "SPHERE", 0, "Sphere", ""},
{PROP_ROOT, "ROOT", 0, "Root", ""},
{PROP_SHARP, "SHARP", 0, "Sharp", ""},
{PROP_LIN, "LINEAR", 0, "Linear", ""},
{PROP_CONST, "CONSTANT", 0, "Constant", ""},
{PROP_RANDOM, "RANDOM", 0, "Random", ""},
{0, NULL, 0, NULL, NULL}
};
char OP_TRANSLATION[] = "TFM_OT_translation";
@ -133,12 +133,12 @@ static int select_orientation_invoke(bContext *C, wmOperator *op, wmEvent *event
void TFM_OT_select_orientation(struct wmOperatorType *ot)
{
static EnumPropertyItem orientation_items[]= {
{V3D_MANIP_GLOBAL, "GLOBAL", "Global", ""},
{V3D_MANIP_NORMAL, "NORMAL", "Normal", ""},
{V3D_MANIP_LOCAL, "LOCAL", "Local", ""},
{V3D_MANIP_VIEW, "VIEW", "View", ""},
{V3D_MANIP_CUSTOM, "CUSTOM", "Custom", ""},
{0, NULL, NULL, NULL}};
{V3D_MANIP_GLOBAL, "GLOBAL", 0, "Global", ""},
{V3D_MANIP_NORMAL, "NORMAL", 0, "Normal", ""},
{V3D_MANIP_LOCAL, "LOCAL", 0, "Local", ""},
{V3D_MANIP_VIEW, "VIEW", 0, "View", ""},
{V3D_MANIP_CUSTOM, "CUSTOM", 0, "Custom", ""},
{0, NULL, 0, NULL, NULL}};
/* identifiers */
ot->name = "Select Orientation";
@ -484,33 +484,33 @@ void TFM_OT_tosphere(struct wmOperatorType *ot)
void TFM_OT_transform(struct wmOperatorType *ot)
{
static EnumPropertyItem transform_mode_types[] = {
{TFM_INIT, "INIT", "Init", ""},
{TFM_DUMMY, "DUMMY", "Dummy", ""},
{TFM_TRANSLATION, "TRANSLATION", "Translation", ""},
{TFM_ROTATION, "ROTATION", "Rotation", ""},
{TFM_RESIZE, "RESIZE", "Resize", ""},
{TFM_TOSPHERE, "TOSPHERE", "Tosphere", ""},
{TFM_SHEAR, "SHEAR", "Shear", ""},
{TFM_WARP, "WARP", "Warp", ""},
{TFM_SHRINKFATTEN, "SHRINKFATTEN", "Shrinkfatten", ""},
{TFM_TILT, "TILT", "Tilt", ""},
{TFM_TRACKBALL, "TRACKBALL", "Trackball", ""},
{TFM_PUSHPULL, "PUSHPULL", "Pushpull", ""},
{TFM_CREASE, "CREASE", "Crease", ""},
{TFM_MIRROR, "MIRROR", "Mirror", ""},
{TFM_BONESIZE, "BONESIZE", "Bonesize", ""},
{TFM_BONE_ENVELOPE, "BONE_ENVELOPE", "Bone_Envelope", ""},
{TFM_CURVE_SHRINKFATTEN, "CURVE_SHRINKFATTEN", "Curve_Shrinkfatten", ""},
{TFM_BONE_ROLL, "BONE_ROLL", "Bone_Roll", ""},
{TFM_TIME_TRANSLATE, "TIME_TRANSLATE", "Time_Translate", ""},
{TFM_TIME_SLIDE, "TIME_SLIDE", "Time_Slide", ""},
{TFM_TIME_SCALE, "TIME_SCALE", "Time_Scale", ""},
{TFM_TIME_EXTEND, "TIME_EXTEND", "Time_Extend", ""},
{TFM_BAKE_TIME, "BAKE_TIME", "Bake_Time", ""},
{TFM_BEVEL, "BEVEL", "Bevel", ""},
{TFM_BWEIGHT, "BWEIGHT", "Bweight", ""},
{TFM_ALIGN, "ALIGN", "Align", ""},
{0, NULL, NULL, NULL}
{TFM_INIT, "INIT", 0, "Init", ""},
{TFM_DUMMY, "DUMMY", 0, "Dummy", ""},
{TFM_TRANSLATION, "TRANSLATION", 0, "Translation", ""},
{TFM_ROTATION, "ROTATION", 0, "Rotation", ""},
{TFM_RESIZE, "RESIZE", 0, "Resize", ""},
{TFM_TOSPHERE, "TOSPHERE", 0, "Tosphere", ""},
{TFM_SHEAR, "SHEAR", 0, "Shear", ""},
{TFM_WARP, "WARP", 0, "Warp", ""},
{TFM_SHRINKFATTEN, "SHRINKFATTEN", 0, "Shrinkfatten", ""},
{TFM_TILT, "TILT", 0, "Tilt", ""},
{TFM_TRACKBALL, "TRACKBALL", 0, "Trackball", ""},
{TFM_PUSHPULL, "PUSHPULL", 0, "Pushpull", ""},
{TFM_CREASE, "CREASE", 0, "Crease", ""},
{TFM_MIRROR, "MIRROR", 0, "Mirror", ""},
{TFM_BONESIZE, "BONESIZE", 0, "Bonesize", ""},
{TFM_BONE_ENVELOPE, "BONE_ENVELOPE", 0, "Bone_Envelope", ""},
{TFM_CURVE_SHRINKFATTEN, "CURVE_SHRINKFATTEN", 0, "Curve_Shrinkfatten", ""},
{TFM_BONE_ROLL, "BONE_ROLL", 0, "Bone_Roll", ""},
{TFM_TIME_TRANSLATE, "TIME_TRANSLATE", 0, "Time_Translate", ""},
{TFM_TIME_SLIDE, "TIME_SLIDE", 0, "Time_Slide", ""},
{TFM_TIME_SCALE, "TIME_SCALE", 0, "Time_Scale", ""},
{TFM_TIME_EXTEND, "TIME_EXTEND", 0, "Time_Extend", ""},
{TFM_BAKE_TIME, "BAKE_TIME", 0, "Bake_Time", ""},
{TFM_BEVEL, "BEVEL", 0, "Bevel", ""},
{TFM_BWEIGHT, "BWEIGHT", 0, "Bweight", ""},
{TFM_ALIGN, "ALIGN", 0, "Align", ""},
{0, NULL, 0, NULL, NULL}
};
/* identifiers */

28
source/blender/editors/uvedit/uvedit_ops.c
View File

@ -963,9 +963,9 @@ static int mirror_exec(bContext *C, wmOperator *op)
void UV_OT_mirror(wmOperatorType *ot)
{
static EnumPropertyItem axis_items[] = {
{'x', "MIRROR_X", "Mirror X", "Mirror UVs over X axis."},
{'y', "MIRROR_Y", "Mirror Y", "Mirror UVs over Y axis."},
{0, NULL, NULL, NULL}};
{'x', "MIRROR_X", 0, "Mirror X", "Mirror UVs over X axis."},
{'y', "MIRROR_Y", 0, "Mirror Y", "Mirror UVs over Y axis."},
{0, NULL, 0, NULL, NULL}};
/* identifiers */
ot->name= "Mirror";
@ -1068,10 +1068,10 @@ static int align_exec(bContext *C, wmOperator *op)
void UV_OT_align(wmOperatorType *ot)
{
static EnumPropertyItem axis_items[] = {
{'a', "ALIGN_AUTO", "Align Auto", "Automatically choose the axis on which there is most alignment already."},
{'x', "ALIGN_X", "Align X", "Align UVs on X axis."},
{'y', "ALIGN_Y", "Align Y", "Align UVs on Y axis."},
{0, NULL, NULL, NULL}};
{'a', "ALIGN_AUTO", 0, "Align Auto", "Automatically choose the axis on which there is most alignment already."},
{'x', "ALIGN_X", 0, "Align X", "Align UVs on X axis."},
{'y', "ALIGN_Y", 0, "Align Y", "Align UVs on Y axis."},
{0, NULL, 0, NULL, NULL}};
/* identifiers */
ot->name= "Align";
@ -2326,9 +2326,9 @@ static int snap_cursor_exec(bContext *C, wmOperator *op)
void UV_OT_snap_cursor(wmOperatorType *ot)
{
static EnumPropertyItem target_items[] = {
{0, "PIXELS", "Pixels", ""},
{1, "SELECTION", "Selection", ""},
{0, NULL, NULL, NULL}};
{0, "PIXELS", 0, "Pixels", ""},
{1, "SELECTION", 0, "Selection", ""},
{0, NULL, 0, NULL, NULL}};
/* identifiers */
ot->name= "Snap Cursor";
@ -2561,10 +2561,10 @@ static int snap_selection_exec(bContext *C, wmOperator *op)
void UV_OT_snap_selection(wmOperatorType *ot)
{
static EnumPropertyItem target_items[] = {
{0, "PIXELS", "Pixels", ""},
{1, "CURSOR", "Cursor", ""},
{2, "ADJACENT_UNSELECTED", "Adjacent Unselected", ""},
{0, NULL, NULL, NULL}};
{0, "PIXELS", 0, "Pixels", ""},
{1, "CURSOR", 0, "Cursor", ""},
{2, "ADJACENT_UNSELECTED", 0, "Adjacent Unselected", ""},
{0, NULL, 0, NULL, NULL}};
/* identifiers */
ot->name= "Snap Selection";

20
source/blender/editors/uvedit/uvedit_unwrap_ops.c
View File

@ -639,15 +639,15 @@ static void uv_map_transform(bContext *C, wmOperator *op, float center[3], float
static void uv_transform_properties(wmOperatorType *ot, int radius)
{
static EnumPropertyItem direction_items[]= {
{VIEW_ON_EQUATOR, "VIEW_ON_EQUATOR", "View on Equator", "3D view is on the equator."},
{VIEW_ON_POLES, "VIEW_ON_POLES", "View on Poles", "3D view is on the poles."},
{ALIGN_TO_OBJECT, "ALIGN_TO_OBJECT", "Align to Object", "Align according to object transform."},
{0, NULL, NULL, NULL}
{VIEW_ON_EQUATOR, "VIEW_ON_EQUATOR", 0, "View on Equator", "3D view is on the equator."},
{VIEW_ON_POLES, "VIEW_ON_POLES", 0, "View on Poles", "3D view is on the poles."},
{ALIGN_TO_OBJECT, "ALIGN_TO_OBJECT", 0, "Align to Object", "Align according to object transform."},
{0, NULL, 0, NULL, NULL}
};
static EnumPropertyItem align_items[]= {
{POLAR_ZX, "POLAR_ZX", "Polar ZX", "Polar 0 is X."},
{POLAR_ZY, "POLAR_ZY", "Polar ZY", "Polar 0 is Y."},
{0, NULL, NULL, NULL}
{POLAR_ZX, "POLAR_ZX", 0, "Polar ZX", "Polar 0 is X."},
{POLAR_ZY, "POLAR_ZY", 0, "Polar ZY", "Polar 0 is Y."},
{0, NULL, 0, NULL, NULL}
};
RNA_def_enum(ot->srna, "direction", direction_items, VIEW_ON_EQUATOR, "Direction", "Direction of the sphere or cylinder.");
@ -820,9 +820,9 @@ static int unwrap_exec(bContext *C, wmOperator *op)
void UV_OT_unwrap(wmOperatorType *ot)
{
static EnumPropertyItem method_items[] = {
{0, "ANGLE_BASED", "Angle Based", ""},
{1, "CONFORMAL", "Conformal", ""},
{0, NULL, NULL, NULL}};
{0, "ANGLE_BASED", 0, "Angle Based", ""},
{1, "CONFORMAL", 0, "Conformal", ""},
{0, NULL, 0, NULL, NULL}};
/* identifiers */
ot->name= "Unwrap";

3
source/blender/makesrna/RNA_access.h
View File

@ -479,6 +479,8 @@ void RNA_pointer_create(struct ID *id, StructRNA *type, void *data, PointerRNA *
void RNA_blender_rna_pointer_create(PointerRNA *r_ptr);
extern PointerRNA PointerRNA_NULL;
/* Structs */
const char *RNA_struct_identifier(StructRNA *type);
@ -527,6 +529,7 @@ int RNA_property_string_maxlength(PropertyRNA *prop);
const char *RNA_property_ui_name(PropertyRNA *prop);
const char *RNA_property_ui_description(PropertyRNA *prop);
int RNA_property_ui_icon(PropertyRNA *prop);
/* Dynamic Property Information */

1
source/blender/makesrna/RNA_define.h
View File

@ -136,6 +136,7 @@ void RNA_def_property_string_default(PropertyRNA *prop, const char *value);
void RNA_def_property_ui_text(PropertyRNA *prop, const char *name, const char *description);
void RNA_def_property_ui_range(PropertyRNA *prop, double min, double max, double step, int precision);
void RNA_def_property_ui_icon(PropertyRNA *prop, int icon, int consecutive);
void RNA_def_property_update(PropertyRNA *prop, int noteflag, const char *updatefunc);
void RNA_def_property_editable_func(PropertyRNA *prop, const char *editable);

5
source/blender/makesrna/RNA_types.h
View File

@ -91,9 +91,13 @@ typedef enum PropertyFlag {
* and collections */
PROP_ANIMATEABLE = 2,
/* icon */
PROP_ICONS_CONSECUTIVE = 4096,
/* function paramater flags */
PROP_REQUIRED = 4,
PROP_RETURN = 8,
PROP_RNAPTR = 2048,
/* registering */
PROP_REGISTER = 16,
@ -133,6 +137,7 @@ typedef struct CollectionPointerLink {
typedef struct EnumPropertyItem {
int value;
const char *identifier;
int icon;
const char *name;
const char *description;
} EnumPropertyItem;

2
source/blender/makesrna/SConscript
View File

@ -7,6 +7,6 @@ o = SConscript('intern/SConscript')
objs += o
incs = '#/intern/guardedalloc ../blenkernel ../blenlib ../makesdna intern .'
incs += ' ../windowmanager ../editors/include'
incs += ' ../windowmanager ../editors/include ../imbuf'
env.BlenderLib ( 'bf_rna', objs, Split(incs), [], libtype=['core'], priority = [195] )

2
source/blender/makesrna/intern/CMakeLists.txt
View File

@ -38,7 +38,7 @@ SET(SRC
../../../../intern/guardedalloc/intern/mallocn.c
../../../../intern/guardedalloc/intern/mmap_win.c)
INCLUDE_DIRECTORIES(../../../../intern/guardedalloc .. ../../makesdna ../../blenkernel ../../blenlib ../../windowmanager ../../editors/include .)
INCLUDE_DIRECTORIES(../../../../intern/guardedalloc .. ../../makesdna ../../blenkernel ../../blenlib ../../windowmanager ../../editors/include ../../imbuf .)
FILE(GLOB INC_FILES ../*.h ../../makesdna/*.h)
IF(WITH_OPENEXR)

1
source/blender/makesrna/intern/Makefile
View File

@ -47,6 +47,7 @@ CFLAGS += $(LEVEL_1_C_WARNINGS)
CPPFLAGS += -I$(NAN_GUARDEDALLOC)/include
CPPFLAGS += -I../../blenlib
CPPFLAGS += -I../../blenkernel
CPPFLAGS += -I../../imbuf
CPPFLAGS += -I../../makesdna
CPPFLAGS += -I../../windowmanager
CPPFLAGS += -I../../editors/include

4
source/blender/makesrna/intern/SConscript
View File

@ -41,11 +41,15 @@ if env['WITH_BF_FFMPEG']:
if env['WITH_BF_QUICKTIME']:
defs.append('WITH_QUICKTIME')
if env['WITH_BF_LCMS']:
defs.append('WITH_LCMS')
makesrna_tool.Append(CPPDEFINES=defs)
makesrna_tool.Append (CPPPATH = ['#/intern/guardedalloc',
'../../blenlib',
'../../blenkernel',
'../../imbuf',
'../../makesdna',
'../../makesrna',
'../../windowmanager',

8
source/blender/makesrna/intern/makesrna.c
View File

@ -242,7 +242,7 @@ static const char *rna_parameter_type_name(PropertyRNA *parm)
case PROP_POINTER: {
PointerPropertyRNA *pparm= (PointerPropertyRNA*)parm;
if(strcmp((char*)pparm->type, "AnyType") == 0)
if(parm->flag & PROP_RNAPTR)
return "PointerRNA";
else
return rna_find_dna_type((const char *)pparm->type);
@ -1146,9 +1146,7 @@ static void rna_def_function_funcs(FILE *f, StructDefRNA *dsrna, FunctionDefRNA
else if(dparm->prop->arraylength)
fprintf(f, "\t%s= ((%s%s*)_data);\n", dparm->prop->identifier, rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop));
else if(dparm->prop->type == PROP_POINTER) {
PointerPropertyRNA *pprop= (PointerPropertyRNA*)dparm->prop;
if(strcmp((char*)pprop->type, "AnyType") == 0)
if(dparm->prop->flag & PROP_RNAPTR)
fprintf(f, "\t%s= ((%s%s*)_data);\n", dparm->prop->identifier, rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop));
else
fprintf(f, "\t%s= *((%s%s**)_data);\n", dparm->prop->identifier, rna_type_struct(dparm->prop), rna_parameter_type_name(dparm->prop));
@ -1467,6 +1465,7 @@ static void rna_generate_property(FILE *f, StructRNA *srna, const char *nest, Pr
for(i=0; i<eprop->totitem; i++) {
fprintf(f, "{%d, ", eprop->item[i].value);
rna_print_c_string(f, eprop->item[i].identifier); fprintf(f, ", ");
fprintf(f, "%d, ", eprop->item[i].icon);
rna_print_c_string(f, eprop->item[i].name); fprintf(f, ", ");
rna_print_c_string(f, eprop->item[i].description); fprintf(f, "}");
if(i != eprop->totitem-1)
@ -1565,6 +1564,7 @@ static void rna_generate_property(FILE *f, StructRNA *srna, const char *nest, Pr
fprintf(f, ", %d, ", prop->flag);
rna_print_c_string(f, prop->name); fprintf(f, ",\n\t");
rna_print_c_string(f, prop->description); fprintf(f, ",\n");
fprintf(f, "%d, ", prop->icon);
fprintf(f, "\t%s, %s, %d,\n", rna_property_typename(prop->type), rna_property_subtypename(prop->subtype), prop->arraylength);
fprintf(f, "\t%s, %d, %s},\n", rna_function_string(prop->update), prop->noteflag, rna_function_string(prop->editable));

9
source/blender/makesrna/intern/rna_access.c
View File

@ -53,6 +53,8 @@ void RNA_exit()
/* Pointer */
PointerRNA PointerRNA_NULL = {{0}, 0, 0};
void RNA_main_pointer_create(struct Main *main, PointerRNA *r_ptr)
{
r_ptr->id.data= NULL;
@ -677,6 +679,11 @@ const char *RNA_property_ui_description(PropertyRNA *prop)
return rna_ensure_property(prop)->description;
}
int RNA_property_ui_icon(PropertyRNA *prop)
{
return rna_ensure_property(prop)->icon;
}
int RNA_property_editable(PointerRNA *ptr, PropertyRNA *prop)
{
ID *id;
@ -2674,7 +2681,7 @@ static int rna_function_parameter_parse(PointerRNA *ptr, PropertyRNA *prop, Prop
ptype= RNA_property_pointer_type(ptr, prop);
if(ptype == &RNA_AnyType) {
if(prop->flag & PROP_RNAPTR) {
*((PointerRNA*)dest)= *((PointerRNA*)src);
}
else if (ptype!=srna) {

38
source/blender/makesrna/intern/rna_actuator.c
View File

@ -41,25 +41,25 @@ void RNA_def_actuator(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem actuator_type_items[] ={
{ACT_OBJECT, "OBJECT", "Object", ""},
{ACT_IPO, "IPO", "IPO", ""},
{ACT_CAMERA, "CAMERA", "Camera", ""},
{ACT_SOUND, "SOUND", "Sound", ""},
{ACT_PROPERTY, "PROPERTY", "Property", ""},
{ACT_CONSTRAINT, "CONSTRAINT", "Constraint", ""},
{ACT_EDIT_OBJECT, "EDIT_OBJECT", "Edit Object", ""},
{ACT_SCENE, "SCENE", "Scene", ""},
{ACT_RANDOM, "RANDOM", "Random", ""},
{ACT_MESSAGE, "MESSAGE", "Message", ""},
{ACT_ACTION, "ACTION", "Action", ""},
{ACT_CD, "CD", "CD", ""},
{ACT_GAME, "GAME", "Game", ""},
{ACT_VISIBILITY, "VISIBILITY", "Visibility", ""},
{ACT_2DFILTER, "FILTER_2D", "2D Filter", ""},
{ACT_PARENT, "PARENT", "Parent", ""},
{ACT_SHAPEACTION, "SHAPE_ACTION", "Shape Action", ""},
{ACT_STATE, "STATE", "State", ""},
{0, NULL, NULL, NULL}};
{ACT_OBJECT, "OBJECT", 0, "Object", ""},
{ACT_IPO, "IPO", 0, "IPO", ""},
{ACT_CAMERA, "CAMERA", 0, "Camera", ""},
{ACT_SOUND, "SOUND", 0, "Sound", ""},
{ACT_PROPERTY, "PROPERTY", 0, "Property", ""},
{ACT_CONSTRAINT, "CONSTRAINT", 0, "Constraint", ""},
{ACT_EDIT_OBJECT, "EDIT_OBJECT", 0, "Edit Object", ""},
{ACT_SCENE, "SCENE", 0, "Scene", ""},
{ACT_RANDOM, "RANDOM", 0, "Random", ""},
{ACT_MESSAGE, "MESSAGE", 0, "Message", ""},
{ACT_ACTION, "ACTION", 0, "Action", ""},
{ACT_CD, "CD", 0, "CD", ""},
{ACT_GAME, "GAME", 0, "Game", ""},
{ACT_VISIBILITY, "VISIBILITY", 0, "Visibility", ""},
{ACT_2DFILTER, "FILTER_2D", 0, "2D Filter", ""},
{ACT_PARENT, "PARENT", 0, "Parent", ""},
{ACT_SHAPEACTION, "SHAPE_ACTION", 0, "Shape Action", ""},
{ACT_STATE, "STATE", 0, "State", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "Actuator", NULL);
RNA_def_struct_ui_text(srna, "Actuator", "Game engine logic brick to apply actions in the game engine.");

10
source/blender/makesrna/intern/rna_animation.c
View File

@ -79,11 +79,11 @@ void rna_def_keyingset_path(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_mode_grouping_items[] = {
{KSP_GROUP_NAMED, "NAMED", "Named Group", ""},
{KSP_GROUP_NONE, "NONE", "None", ""},
{KSP_GROUP_KSNAME, "KEYINGSET", "Keying Set Name", ""},
{KSP_GROUP_TEMPLATE_ITEM, "TEMPLATE", "Innermost Context-Item Name", ""},
{0, NULL, NULL, NULL}};
{KSP_GROUP_NAMED, "NAMED", 0, "Named Group", ""},
{KSP_GROUP_NONE, "NONE", 0, "None", ""},
{KSP_GROUP_KSNAME, "KEYINGSET", 0, "Keying Set Name", ""},
{KSP_GROUP_TEMPLATE_ITEM, "TEMPLATE", 0, "Innermost Context-Item Name", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "KeyingSetPath", NULL);
RNA_def_struct_sdna(srna, "KS_Path");

18
source/blender/makesrna/intern/rna_armature.c
View File

@ -256,16 +256,16 @@ void rna_def_armature(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_drawtype_items[] = {
{ARM_OCTA, "OCTAHEDRAL", "Octahedral", "Draw bones as octahedral shape (default)."},
{ARM_LINE, "STICK", "Stick", "Draw bones as simple 2D lines with dots."},
{ARM_B_BONE, "BBONE", "B-Bone", "Draw bones as boxes, showing subdivision and B-Splines"},
{ARM_ENVELOPE, "ENVELOPE", "Envelope", "Draw bones as extruded spheres, showing defomation influence volume."},
{0, NULL, NULL, NULL}};
{ARM_OCTA, "OCTAHEDRAL", 0, "Octahedral", "Draw bones as octahedral shape (default)."},
{ARM_LINE, "STICK", 0, "Stick", "Draw bones as simple 2D lines with dots."},
{ARM_B_BONE, "BBONE", 0, "B-Bone", "Draw bones as boxes, showing subdivision and B-Splines"},
{ARM_ENVELOPE, "ENVELOPE", 0, "Envelope", "Draw bones as extruded spheres, showing defomation influence volume."},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem prop_ghost_type_items[] = {
{ARM_GHOST_CUR, "CURRENT_FRAME", "Around Current Frame", "Draw Ghosts of poses within a fixed number of frames around the current frame."},
{ARM_GHOST_RANGE, "RANGE", "In Range", "Draw Ghosts of poses within specified range."},
{ARM_GHOST_KEYS, "KEYS", "On Keyframes", "Draw Ghosts of poses on Keyframes."},
{0, NULL, NULL, NULL}};
{ARM_GHOST_CUR, "CURRENT_FRAME", 0, "Around Current Frame", "Draw Ghosts of poses within a fixed number of frames around the current frame."},
{ARM_GHOST_RANGE, "RANGE", 0, "In Range", "Draw Ghosts of poses within specified range."},
{ARM_GHOST_KEYS, "KEYS", 0, "On Keyframes", "Draw Ghosts of poses on Keyframes."},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "Armature", "ID");
RNA_def_struct_ui_text(srna, "Armature", "Armature datablock containing a hierarchy of bones, usually used for rigging characters.");

42
source/blender/makesrna/intern/rna_brush.c
View File

@ -67,29 +67,29 @@ void rna_def_brush(BlenderRNA *brna)
StructRNA *srna;
PropertyRNA *prop;
static EnumPropertyItem prop_blend_items[] = {
{BRUSH_BLEND_MIX, "MIX", "Mix", "Use mix blending mode while painting."},
{BRUSH_BLEND_ADD, "ADD", "Add", "Use add blending mode while painting."},
{BRUSH_BLEND_SUB, "SUB", "Subtract", "Use subtract blending mode while painting."},
{BRUSH_BLEND_MUL, "MUL", "Multiply", "Use multiply blending mode while painting."},
{BRUSH_BLEND_LIGHTEN, "LIGHTEN", "Lighten", "Use lighten blending mode while painting."},
{BRUSH_BLEND_DARKEN, "DARKEN", "Darken", "Use darken blending mode while painting."},
{BRUSH_BLEND_ERASE_ALPHA, "ERASE_ALPHA", "Erase Alpha", "Erase alpha while painting."},
{BRUSH_BLEND_ADD_ALPHA, "ADD_ALPHA", "Add Alpha", "Add alpha while painting."},
{0, NULL, NULL, NULL}};
{BRUSH_BLEND_MIX, "MIX", 0, "Mix", "Use mix blending mode while painting."},
{BRUSH_BLEND_ADD, "ADD", 0, "Add", "Use add blending mode while painting."},
{BRUSH_BLEND_SUB, "SUB", 0, "Subtract", "Use subtract blending mode while painting."},
{BRUSH_BLEND_MUL, "MUL", 0, "Multiply", "Use multiply blending mode while painting."},
{BRUSH_BLEND_LIGHTEN, "LIGHTEN", 0, "Lighten", "Use lighten blending mode while painting."},
{BRUSH_BLEND_DARKEN, "DARKEN", 0, "Darken", "Use darken blending mode while painting."},
{BRUSH_BLEND_ERASE_ALPHA, "ERASE_ALPHA", 0, "Erase Alpha", "Erase alpha while painting."},
{BRUSH_BLEND_ADD_ALPHA, "ADD_ALPHA", 0, "Add Alpha", "Add alpha while painting."},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem prop_texture_mode_items[] = {
{BRUSH_TEX_DRAG, "TEX_DRAG", "Drag", ""},
{BRUSH_TEX_TILE, "TEX_TILE", "Tile", ""},
{BRUSH_TEX_3D, "TEX_3D", "3D", ""},
{0, NULL, NULL, NULL}};
{BRUSH_TEX_DRAG, "TEX_DRAG", 0, "Drag", ""},
{BRUSH_TEX_TILE, "TEX_TILE", 0, "Tile", ""},
{BRUSH_TEX_3D, "TEX_3D", 0, "3D", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem prop_sculpt_tool_items[] = {
{SCULPT_TOOL_DRAW, "DRAW", "Draw", ""},
{SCULPT_TOOL_SMOOTH, "SMOOTH", "Smooth", ""},
{SCULPT_TOOL_PINCH, "PINCH", "Pinch", ""},
{SCULPT_TOOL_INFLATE, "INFLATE", "Inflate", ""},
{SCULPT_TOOL_GRAB, "GRAB", "Grab", ""},
{SCULPT_TOOL_LAYER, "LAYER", "Layer", ""},
{SCULPT_TOOL_FLATTEN, "FLATTEN", "Flatten", ""},
{0, NULL, NULL, NULL}};
{SCULPT_TOOL_DRAW, "DRAW", 0, "Draw", ""},
{SCULPT_TOOL_SMOOTH, "SMOOTH", 0, "Smooth", ""},
{SCULPT_TOOL_PINCH, "PINCH", 0, "Pinch", ""},
{SCULPT_TOOL_INFLATE, "INFLATE", 0, "Inflate", ""},
{SCULPT_TOOL_GRAB, "GRAB", 0, "Grab", ""},
{SCULPT_TOOL_LAYER, "LAYER", 0, "Layer", ""},
{SCULPT_TOOL_FLATTEN, "FLATTEN", 0, "Flatten", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "Brush", "ID");
RNA_def_struct_ui_text(srna, "Brush", "Brush datablock for storing brush settings for painting and sculpting.");

12
source/blender/makesrna/intern/rna_camera.c
View File

@ -42,13 +42,13 @@ void RNA_def_camera(BlenderRNA *brna)
StructRNA *srna;
PropertyRNA *prop;
static EnumPropertyItem prop_type_items[] = {
{CAM_PERSP, "PERSP", "Perspective", ""},
{CAM_ORTHO, "ORTHO", "Orthographic", ""},
{0, NULL, NULL, NULL}};
{CAM_PERSP, "PERSP", 0, "Perspective", ""},
{CAM_ORTHO, "ORTHO", 0, "Orthographic", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem prop_lens_unit_items[] = {
{0, "MILLIMETERS", "Millimeters", ""},
{CAM_ANGLETOGGLE, "DEGREES", "Degrees", ""},
{0, NULL, NULL, NULL}};
{0, "MILLIMETERS", 0, "Millimeters", ""},
{CAM_ANGLETOGGLE, "DEGREES", 0, "Degrees", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "Camera", "ID");
RNA_def_struct_ui_text(srna, "Camera", "Camera datablock for storing camera settings.");

12
source/blender/makesrna/intern/rna_color.c
View File

@ -120,9 +120,9 @@ static void rna_def_curvemappoint(BlenderRNA *brna)
StructRNA *srna;
PropertyRNA *prop;
static EnumPropertyItem prop_handle_type_items[] = {
{0, "AUTO", "Auto Handle", ""},
{CUMA_VECTOR, "VECTOR", "Vector Handle", ""},
{0, NULL, NULL, NULL}
{0, "AUTO", 0, "Auto Handle", ""},
{CUMA_VECTOR, "VECTOR", 0, "Vector Handle", ""},
{0, NULL, 0, NULL, NULL}
};
srna= RNA_def_struct(brna, "CurveMapPoint", NULL);
@ -152,9 +152,9 @@ static void rna_def_curvemap(BlenderRNA *brna)
StructRNA *srna;
PropertyRNA *prop;
static EnumPropertyItem prop_extend_items[] = {
{0, "HORIZONTAL", "Horizontal", ""},
{CUMA_EXTEND_EXTRAPOLATE, "EXTRAPOLATED", "Extrapolated", ""},
{0, NULL, NULL, NULL}
{0, "HORIZONTAL", 0, "Horizontal", ""},
{CUMA_EXTEND_EXTRAPOLATE, "EXTRAPOLATED", 0, "Extrapolated", ""},
{0, NULL, 0, NULL, NULL}
};
srna= RNA_def_struct(brna, "CurveMap", NULL);

228
source/blender/makesrna/intern/rna_constraint.c
View File

@ -36,37 +36,37 @@
#include "WM_types.h"
EnumPropertyItem constraint_type_items[] ={
{CONSTRAINT_TYPE_CHILDOF, "CHILD_OF", "Child Of", ""},
{CONSTRAINT_TYPE_TRANSFORM, "TRANSFORM", "Transformation", ""},
{CONSTRAINT_TYPE_CHILDOF, "CHILD_OF", 0, "Child Of", ""},
{CONSTRAINT_TYPE_TRANSFORM, "TRANSFORM", 0, "Transformation", ""},
{CONSTRAINT_TYPE_LOCLIKE, "COPY_LOCATION", "Copy Location", ""},
{CONSTRAINT_TYPE_ROTLIKE, "COPY_ROTATION", "Copy Rotation", ""},
{CONSTRAINT_TYPE_SIZELIKE, "COPY_SCALE", "Copy Scale", ""},
{CONSTRAINT_TYPE_LOCLIKE, "COPY_LOCATION", 0, "Copy Location", ""},
{CONSTRAINT_TYPE_ROTLIKE, "COPY_ROTATION", 0, "Copy Rotation", ""},
{CONSTRAINT_TYPE_SIZELIKE, "COPY_SCALE", 0, "Copy Scale", ""},
{CONSTRAINT_TYPE_LOCLIMIT, "LIMIT_LOCATION", "Limit Location", ""},
{CONSTRAINT_TYPE_ROTLIMIT, "LIMIT_ROTATION", "Limit Rotation", ""},
{CONSTRAINT_TYPE_SIZELIMIT, "LIMIT_SCALE", "Limit Scale", ""},
{CONSTRAINT_TYPE_DISTLIMIT, "LIMIT_DISTANCE", "Limit Distance", ""},
{CONSTRAINT_TYPE_LOCLIMIT, "LIMIT_LOCATION", 0, "Limit Location", ""},
{CONSTRAINT_TYPE_ROTLIMIT, "LIMIT_ROTATION", 0, "Limit Rotation", ""},
{CONSTRAINT_TYPE_SIZELIMIT, "LIMIT_SCALE", 0, "Limit Scale", ""},
{CONSTRAINT_TYPE_DISTLIMIT, "LIMIT_DISTANCE", 0, "Limit Distance", ""},
{CONSTRAINT_TYPE_TRACKTO, "TRACK_TO", "Track To", ""},
{CONSTRAINT_TYPE_LOCKTRACK, "LOCKED_TRACK", "Locked Track", ""},
{CONSTRAINT_TYPE_TRACKTO, "TRACK_TO", 0, "Track To", ""},
{CONSTRAINT_TYPE_LOCKTRACK, "LOCKED_TRACK", 0, "Locked Track", ""},
{CONSTRAINT_TYPE_MINMAX, "FLOOR", "Floor", ""},
{CONSTRAINT_TYPE_SHRINKWRAP, "SHRINKWRAP", "Shrinkwrap", ""},
{CONSTRAINT_TYPE_FOLLOWPATH, "FOLLOW_PATH", "Follow Path", ""},
{CONSTRAINT_TYPE_MINMAX, "FLOOR", 0, "Floor", ""},
{CONSTRAINT_TYPE_SHRINKWRAP, "SHRINKWRAP", 0, "Shrinkwrap", ""},
{CONSTRAINT_TYPE_FOLLOWPATH, "FOLLOW_PATH", 0, "Follow Path", ""},
{CONSTRAINT_TYPE_CLAMPTO, "CLAMP_TO", "Clamp To", ""},
{CONSTRAINT_TYPE_STRETCHTO, "STRETCH_TO", "Stretch To", ""},
{CONSTRAINT_TYPE_CLAMPTO, "CLAMP_TO", 0, "Clamp To", ""},
{CONSTRAINT_TYPE_STRETCHTO, "STRETCH_TO", 0, "Stretch To", ""},
{CONSTRAINT_TYPE_KINEMATIC, "IK", "IK", ""},
{CONSTRAINT_TYPE_RIGIDBODYJOINT, "RIGID_BODY_JOINT", "Rigid Body Joint", ""},
{CONSTRAINT_TYPE_KINEMATIC, "IK", 0, "IK", ""},
{CONSTRAINT_TYPE_RIGIDBODYJOINT, "RIGID_BODY_JOINT", 0, "Rigid Body Joint", ""},
{CONSTRAINT_TYPE_ACTION, "ACTION", "Action", ""},
{CONSTRAINT_TYPE_ACTION, "ACTION", 0, "Action", ""},
{CONSTRAINT_TYPE_PYTHON, "SCRIPT", "Script", ""},
{CONSTRAINT_TYPE_PYTHON, "SCRIPT", 0, "Script", ""},
{CONSTRAINT_TYPE_NULL, "NULL", "Null", ""},
{0, NULL, NULL, NULL}};
{CONSTRAINT_TYPE_NULL, "NULL", 0, "Null", ""},
{0, NULL, 0, NULL, NULL}};
#ifdef RNA_RUNTIME
@ -167,16 +167,16 @@ static void rna_Constraint_influence_update(bContext *C, PointerRNA *ptr)
}
static EnumPropertyItem space_pchan_items[] = {
{0, "WORLD", "World Space", ""},
{2, "POSE", "Pose Space", ""},
{3, "LOCAL_WITH_PARENT", "Local With Parent", ""},
{1, "LOCAL", "Local Space", ""},
{0, NULL, NULL, NULL}};
{0, "WORLD", 0, "World Space", ""},
{2, "POSE", 0, "Pose Space", ""},
{3, "LOCAL_WITH_PARENT", 0, "Local With Parent", ""},
{1, "LOCAL", 0, "Local Space", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem space_object_items[] = {
{0, "WORLD", "World Space", ""},
{1, "LOCAL", "Local (Without Parent) Space", ""},
{0, NULL, NULL, NULL}};
{0, "WORLD", 0, "World Space", ""},
{1, "LOCAL", 0, "Local (Without Parent) Space", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem *rna_Constraint_owner_space_itemf(PointerRNA *ptr)
{
@ -424,19 +424,19 @@ static void rna_def_constraint_track_to(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem track_items[] = {
{TRACK_X, "TRACK_X", "X", ""},
{TRACK_Y, "TRACK_Y", "Y", ""},
{TRACK_Z, "TRACK_Z", "Z", ""},
{TRACK_nX, "TRACK_NEGATIVE_X", "-X", ""},
{TRACK_nY, "TRACK_NEGATIVE_Y", "-Y", ""},
{TRACK_nZ, "TRACK_NEGATIVE_Z", "-Z", ""},
{0, NULL, NULL, NULL}};
{TRACK_X, "TRACK_X", 0, "X", ""},
{TRACK_Y, "TRACK_Y", 0, "Y", ""},
{TRACK_Z, "TRACK_Z", 0, "Z", ""},
{TRACK_nX, "TRACK_NEGATIVE_X", 0, "-X", ""},
{TRACK_nY, "TRACK_NEGATIVE_Y", 0, "-Y", ""},
{TRACK_nZ, "TRACK_NEGATIVE_Z", 0, "-Z", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem up_items[] = {
{TRACK_X, "UP_X", "X", ""},
{TRACK_Y, "UP_Y", "Y", ""},
{TRACK_Z, "UP_Z", "Z", ""},
{0, NULL, NULL, NULL}};
{TRACK_X, "UP_X", 0, "X", ""},
{TRACK_Y, "UP_Y", 0, "Y", ""},
{TRACK_Z, "UP_Z", 0, "Z", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "TrackToConstraint", "Constraint");
RNA_def_struct_ui_text(srna, "Track To Constraint", "Aims the constrained object toward the target.");
@ -597,13 +597,13 @@ static void rna_def_constraint_minmax(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem minmax_items[] = {
{LOCLIKE_X, "FLOOR_X", "X", ""},
{LOCLIKE_Y, "FLOOR_Y", "Y", ""},
{LOCLIKE_Z, "FLOOR_Z", "Z", ""},
{LOCLIKE_X_INVERT, "FLOOR_NEGATIVE_X", "-X", ""},
{LOCLIKE_Y_INVERT, "FLOOR_NEGATIVE_Y", "-Y", ""},
{LOCLIKE_Z_INVERT, "FLOOR_NEGATIVE_Z", "-Z", ""},
{0, NULL, NULL, NULL}};
{LOCLIKE_X, "FLOOR_X", 0, "X", ""},
{LOCLIKE_Y, "FLOOR_Y", 0, "Y", ""},
{LOCLIKE_Z, "FLOOR_Z", 0, "Z", ""},
{LOCLIKE_X_INVERT, "FLOOR_NEGATIVE_X", 0, "-X", ""},
{LOCLIKE_Y_INVERT, "FLOOR_NEGATIVE_Y", 0, "-Y", ""},
{LOCLIKE_Z_INVERT, "FLOOR_NEGATIVE_Z", 0, "-Z", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "FloorConstraint", "Constraint");
RNA_def_struct_ui_text(srna, "Floor Constraint", "Uses the target object for location limitation.");
@ -690,16 +690,16 @@ static void rna_def_constraint_action(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem transform_channel_items[] = {
{00, "ROTATION_X", "Rotation X", ""},
{01, "ROTATION_Y", "Rotation Y", ""},
{02, "ROTATION_Z", "Rotation Z", ""},
{10, "SIZE_X", "Scale X", ""},
{11, "SIZE_Y", "Scale Y", ""},
{12, "SIZE_Z", "Scale Z", ""},
{20, "LOCATION_X", "Location X", ""},
{21, "LOCATION_Y", "Location Y", ""},
{22, "LOCATION_Z", "Location Z", ""},
{0, NULL, NULL, NULL}};
{00, "ROTATION_X", 0, "Rotation X", ""},
{01, "ROTATION_Y", 0, "Rotation Y", ""},
{02, "ROTATION_Z", 0, "Rotation Z", ""},
{10, "SIZE_X", 0, "Scale X", ""},
{11, "SIZE_Y", 0, "Scale Y", ""},
{12, "SIZE_Z", 0, "Scale Z", ""},
{20, "LOCATION_X", 0, "Location X", ""},
{21, "LOCATION_Y", 0, "Location Y", ""},
{22, "LOCATION_Z", 0, "Location Z", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "ActionConstraint", "Constraint");
RNA_def_struct_ui_text(srna, "Action Constraint", "Map an action to the transform axes of a bone.");
@ -759,19 +759,19 @@ static void rna_def_constraint_locked_track(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem locktrack_items[] = {
{TRACK_X, "TRACK_X", "X", ""},
{TRACK_Y, "TRACK_Y", "Y", ""},
{TRACK_Z, "TRACK_Z", "Z", ""},
{TRACK_nX, "TRACK_NEGATIVE_X", "-X", ""},
{TRACK_nY, "TRACK_NEGATIVE_Y", "-Y", ""},
{TRACK_nZ, "TRACK_NEGATIVE_Z", "-Z", ""},
{0, NULL, NULL, NULL}};
{TRACK_X, "TRACK_X", 0, "X", ""},
{TRACK_Y, "TRACK_Y", 0, "Y", ""},
{TRACK_Z, "TRACK_Z", 0, "Z", ""},
{TRACK_nX, "TRACK_NEGATIVE_X", 0, "-X", ""},
{TRACK_nY, "TRACK_NEGATIVE_Y", 0, "-Y", ""},
{TRACK_nZ, "TRACK_NEGATIVE_Z", 0, "-Z", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem lock_items[] = {
{TRACK_X, "LOCK_X", "X", ""},
{TRACK_Y, "LOCK_Y", "Y", ""},
{TRACK_Z, "LOCK_Z", "Z", ""},
{0, NULL, NULL, NULL}};
{TRACK_X, "LOCK_X", 0, "X", ""},
{TRACK_Y, "LOCK_Y", 0, "Y", ""},
{TRACK_Z, "LOCK_Z", 0, "Z", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "LockedTrackConstraint", "Constraint");
RNA_def_struct_ui_text(srna, "Locked Track Constraint", "Points toward the target along the track axis, while locking the other axis.");
@ -807,19 +807,19 @@ static void rna_def_constraint_follow_path(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem forwardpath_items[] = {
{TRACK_X, "FORWARD_X", "X", ""},
{TRACK_Y, "FORWARD_Y", "Y", ""},
{TRACK_Z, "FORWARD_Z", "Z", ""},
{TRACK_nX, "TRACK_NEGATIVE_X", "-X", ""},
{TRACK_nY, "TRACK_NEGATIVE_Y", "-Y", ""},
{TRACK_nZ, "TRACK_NEGATIVE_Z", "-Z", ""},
{0, NULL, NULL, NULL}};
{TRACK_X, "FORWARD_X", 0, "X", ""},
{TRACK_Y, "FORWARD_Y", 0, "Y", ""},
{TRACK_Z, "FORWARD_Z", 0, "Z", ""},
{TRACK_nX, "TRACK_NEGATIVE_X", 0, "-X", ""},
{TRACK_nY, "TRACK_NEGATIVE_Y", 0, "-Y", ""},
{TRACK_nZ, "TRACK_NEGATIVE_Z", 0, "-Z", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem pathup_items[] = {
{TRACK_X, "UP_X", "X", ""},
{TRACK_Y, "UP_Y", "Y", ""},
{TRACK_Z, "UP_Z", "Z", ""},
{0, NULL, NULL, NULL}};
{TRACK_X, "UP_X", 0, "X", ""},
{TRACK_Y, "UP_Y", 0, "Y", ""},
{TRACK_Z, "UP_Z", 0, "Z", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "FollowPathConstraint", "Constraint");
RNA_def_struct_ui_text(srna, "Follow Path Constraint", "Locks motion to the target path.");
@ -860,16 +860,16 @@ static void rna_def_constraint_stretch_to(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem volume_items[] = {
{VOLUME_XZ, "VOLUME_XZX", "XZ", ""},
{VOLUME_X, "VOLUME_X", "Y", ""},
{VOLUME_Z, "VOLUME_Z", "Z", ""},
{NO_VOLUME, "NO_VOLUME", "None", ""},
{0, NULL, NULL, NULL}};
{VOLUME_XZ, "VOLUME_XZX", 0, "XZ", ""},
{VOLUME_X, "VOLUME_X", 0, "Y", ""},
{VOLUME_Z, "VOLUME_Z", 0, "Z", ""},
{NO_VOLUME, "NO_VOLUME", 0, "None", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem plane_items[] = {
{PLANE_X, "PLANE_X", "X", "Keep X Axis"},
{PLANE_Z, "PLANE_Z", "Z", "Keep Z Axis"},
{0, NULL, NULL, NULL}};
{PLANE_X, "PLANE_X", 0, "X", "Keep X Axis"},
{PLANE_Z, "PLANE_Z", 0, "Z", "Keep Z Axis"},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "StretchToConstraint", "Constraint");
RNA_def_struct_ui_text(srna, "Stretch To Constraint", "Stretches to meet the target object.");
@ -911,11 +911,11 @@ static void rna_def_constraint_rigid_body_joint(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem pivot_items[] = {
{CONSTRAINT_RB_BALL, "BALL", "Ball", ""},
{CONSTRAINT_RB_HINGE, "HINGE", "Hinge", ""},
{CONSTRAINT_RB_CONETWIST, "CONE_TWIST", "Cone Twist", ""},
{CONSTRAINT_RB_GENERIC6DOF, "GENERIC_6_DOF", "Generic 6 DoF", ""},
{0, NULL, NULL, NULL}};
{CONSTRAINT_RB_BALL, "BALL", 0, "Ball", ""},
{CONSTRAINT_RB_HINGE, "HINGE", 0, "Hinge", ""},
{CONSTRAINT_RB_CONETWIST, "CONE_TWIST", 0, "Cone Twist", ""},
{CONSTRAINT_RB_GENERIC6DOF, "GENERIC_6_DOF", 0, "Generic 6 DoF", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "RigidBodyJointConstraint", "Constraint");
RNA_def_struct_ui_text(srna, "Rigid Body Joint Constraint", "For use with the Game Engine.");
@ -995,11 +995,11 @@ static void rna_def_constraint_clamp_to(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem clamp_items[] = {
{CLAMPTO_AUTO, "CLAMPTO_AUTO", "Auto", ""},
{CLAMPTO_X, "CLAMPTO_X", "X", ""},
{CLAMPTO_Y, "CLAMPTO_Y", "Y", ""},
{CLAMPTO_Z, "CLAMPTO_Z", "Z", ""},
{0, NULL, NULL, NULL}};
{CLAMPTO_AUTO, "CLAMPTO_AUTO", 0, "Auto", ""},
{CLAMPTO_X, "CLAMPTO_X", 0, "X", ""},
{CLAMPTO_Y, "CLAMPTO_Y", 0, "Y", ""},
{CLAMPTO_Z, "CLAMPTO_Z", 0, "Z", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "ClampToConstraint", "Constraint");
RNA_def_struct_ui_text(srna, "Clamp To Constraint", "Constrains an object's location to the nearest point along the target path.");
@ -1029,16 +1029,16 @@ static void rna_def_constraint_transform(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem transform_items[] = {
{0, "LOCATION", "Loc", ""},
{1, "ROTATION", "Rot", ""},
{2, "SCALE", "Scale", ""},
{0, NULL, NULL, NULL}};
{0, "LOCATION", 0, "Loc", ""},
{1, "ROTATION", 0, "Rot", ""},
{2, "SCALE", 0, "Scale", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem axis_map_items[] = {
{0, "X", "X", ""},
{1, "Y", "Y", ""},
{2, "Z", "Z", ""},
{0, NULL, NULL, NULL}};
{0, "X", 0, "X", ""},
{1, "Y", 0, "Y", ""},
{2, "Z", 0, "Z", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "TransformConstraint", "Constraint");
RNA_def_struct_ui_text(srna, "Transformation Constraint", "Maps transformations of the target to the object.");
@ -1397,10 +1397,10 @@ static void rna_def_constraint_distance_limit(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem distance_items[] = {
{LIMITDIST_INSIDE, "LIMITDIST_INSIDE", "Inside", ""},
{LIMITDIST_OUTSIDE, "LIMITDIST_OUTSIDE", "Outside", ""},
{LIMITDIST_ONSURFACE, "LIMITDIST_ONSURFACE", "On Surface", ""},
{0, NULL, NULL, NULL}};
{LIMITDIST_INSIDE, "LIMITDIST_INSIDE", 0, "Inside", ""},
{LIMITDIST_OUTSIDE, "LIMITDIST_OUTSIDE", 0, "Outside", ""},
{LIMITDIST_ONSURFACE, "LIMITDIST_ONSURFACE", 0, "On Surface", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "LimitDistanceConstraint", "Constraint");
RNA_def_struct_ui_text(srna, "Limit Distance Constraint", "Limits the distance from target object.");
@ -1436,10 +1436,10 @@ static void rna_def_constraint_shrinkwrap(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem type_items[] = {
{MOD_SHRINKWRAP_NEAREST_SURFACE, "NEAREST_SURFACE", "Nearest Surface Point", ""},
{MOD_SHRINKWRAP_PROJECT, "PROJECT", "Project", ""},
{MOD_SHRINKWRAP_NEAREST_VERTEX, "NEAREST_VERTEX", "Nearest Vertex", ""},
{0, NULL, NULL, NULL}};
{MOD_SHRINKWRAP_NEAREST_SURFACE, "NEAREST_SURFACE", 0, "Nearest Surface Point", ""},
{MOD_SHRINKWRAP_PROJECT, "PROJECT", 0, "Project", ""},
{MOD_SHRINKWRAP_NEAREST_VERTEX, "NEAREST_VERTEX", 0, "Nearest Vertex", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "ShrinkwrapConstraint", "Constraint");
RNA_def_struct_ui_text(srna, "Shrinkwrap Constraint", "Creates constraint-based shrinkwrap relationship.");

16
source/blender/makesrna/intern/rna_context.c
View File

@ -55,25 +55,33 @@ static PointerRNA rna_Context_screen_get(PointerRNA *ptr)
static PointerRNA rna_Context_area_get(PointerRNA *ptr)
{
bContext *C= (bContext*)ptr->data;
return rna_pointer_inherit_refine(ptr, &RNA_Area, CTX_wm_area(C));
PointerRNA newptr;
RNA_pointer_create((ID*)CTX_wm_screen(C), &RNA_Area, CTX_wm_area(C), &newptr);
return newptr;
}
static PointerRNA rna_Context_space_data_get(PointerRNA *ptr)
{
bContext *C= (bContext*)ptr->data;
return rna_pointer_inherit_refine(ptr, &RNA_Space, CTX_wm_space_data(C));
PointerRNA newptr;
RNA_pointer_create((ID*)CTX_wm_screen(C), &RNA_Space, CTX_wm_space_data(C), &newptr);
return newptr;
}
static PointerRNA rna_Context_region_get(PointerRNA *ptr)
{
bContext *C= (bContext*)ptr->data;
return rna_pointer_inherit_refine(ptr, &RNA_Region, CTX_wm_region(C));
PointerRNA newptr;
RNA_pointer_create((ID*)CTX_wm_screen(C), &RNA_Region, CTX_wm_region(C), &newptr);
return newptr;
}
/*static PointerRNA rna_Context_region_data_get(PointerRNA *ptr)
{
bContext *C= (bContext*)ptr->data;
return rna_pointer_inherit_refine(ptr, &RNA_RegionData, CTX_wm_region_data(C));
PointerRNA newptr;
RNA_pointer_create((ID*)CTX_wm_screen(C), &RNA_RegionData, CTX_wm_region_data(C), &newptr);
return newptr;
}*/
static PointerRNA rna_Context_main_get(PointerRNA *ptr)

18
source/blender/makesrna/intern/rna_controller.c
View File

@ -66,15 +66,15 @@ void RNA_def_controller(BlenderRNA *brna)
StructRNA *srna;
PropertyRNA *prop;
static EnumPropertyItem controller_type_items[] ={
{CONT_LOGIC_AND, "LOGIC_AND", "Logic And", ""},
{CONT_LOGIC_OR, "LOGIC_OR", "Logic Or", ""},
{CONT_LOGIC_NAND, "LOGIC_NAND", "Logic Nand", ""},
{CONT_LOGIC_NOR, "LOGIC_NOR", "Logic Nor", ""},
{CONT_LOGIC_XOR, "LOGIC_XOR", "Logic Xor", ""},
{CONT_LOGIC_XNOR, "LOGIC_XNOR", "Logic Xnor", ""},
{CONT_EXPRESSION, "EXPRESSION", "Expression", ""},
{CONT_PYTHON, "PYTHON", "Python Script", ""},
{0, NULL, NULL, NULL}};
{CONT_LOGIC_AND, "LOGIC_AND", 0, "Logic And", ""},
{CONT_LOGIC_OR, "LOGIC_OR", 0, "Logic Or", ""},
{CONT_LOGIC_NAND, "LOGIC_NAND", 0, "Logic Nand", ""},
{CONT_LOGIC_NOR, "LOGIC_NOR", 0, "Logic Nor", ""},
{CONT_LOGIC_XOR, "LOGIC_XOR", 0, "Logic Xor", ""},
{CONT_LOGIC_XNOR, "LOGIC_XNOR", 0, "Logic Xnor", ""},
{CONT_EXPRESSION, "EXPRESSION", 0, "Expression", ""},
{CONT_PYTHON, "PYTHON", 0, "Python Script", ""},
{0, NULL, 0, NULL, NULL}};
/* Controller */
srna= RNA_def_struct(brna, "Controller", NULL);

42
source/blender/makesrna/intern/rna_curve.c
View File

@ -33,18 +33,18 @@
#include "DNA_material_types.h"
EnumPropertyItem beztriple_handle_type_items[] = {
{HD_FREE, "FREE", "Free", ""},
{HD_AUTO, "AUTO", "Auto", ""},
{HD_VECT, "VECTOR", "Vector", ""},
{HD_ALIGN, "ALIGNED", "Aligned", ""},
{HD_AUTO_ANIM, "AUTO_CLAMPED", "Auto Clamped", ""},
{0, NULL, NULL, NULL}};
{HD_FREE, "FREE", 0, "Free", ""},
{HD_AUTO, "AUTO", 0, "Auto", ""},
{HD_VECT, "VECTOR", 0, "Vector", ""},
{HD_ALIGN, "ALIGNED", 0, "Aligned", ""},
{HD_AUTO_ANIM, "AUTO_CLAMPED", 0, "Auto Clamped", ""},
{0, NULL, 0, NULL, NULL}};
EnumPropertyItem beztriple_interpolation_mode_items[] = {
{BEZT_IPO_CONST, "CONSTANT", "Constant", ""},
{BEZT_IPO_LIN, "LINEAR", "Linear", ""},
{BEZT_IPO_BEZ, "BEZIER", "Bezier", ""},
{0, NULL, NULL, NULL}};
{BEZT_IPO_CONST, "CONSTANT", 0, "Constant", ""},
{BEZT_IPO_LIN, "LINEAR", 0, "Linear", ""},
{BEZT_IPO_BEZ, "BEZIER", 0, "Bezier", ""},
{0, NULL, 0, NULL, NULL}};
#ifdef RNA_RUNTIME
@ -307,12 +307,12 @@ static void rna_def_font(BlenderRNA *brna, StructRNA *srna)
PropertyRNA *prop;
static EnumPropertyItem prop_align_items[] = {
{CU_LEFT, "LEFT", "Left", "Align text to the left"},
{CU_MIDDLE, "CENTRAL", "Center", "Center text"},
{CU_RIGHT, "RIGHT", "Right", "Align text to the right"},
{CU_JUSTIFY, "JUSTIFY", "Justify", "Align to the left and the right"},
{CU_FLUSH, "FLUSH", "Flush", "Align to the left and the right, with equal character spacing"},
{0, NULL, NULL, NULL}};
{CU_LEFT, "LEFT", 0, "Left", "Align text to the left"},
{CU_MIDDLE, "CENTRAL", 0, "Center", "Center text"},
{CU_RIGHT, "RIGHT", 0, "Right", "Align text to the right"},
{CU_JUSTIFY, "JUSTIFY", 0, "Justify", "Align to the left and the right"},
{CU_FLUSH, "FLUSH", 0, "Flush", "Align to the left and the right, with equal character spacing"},
{0, NULL, 0, NULL, NULL}};
/* Enums */
prop= RNA_def_property(srna, "spacemode", PROP_ENUM, PROP_NONE);
@ -590,11 +590,11 @@ static void rna_def_curve(BlenderRNA *brna)
static void rna_def_curve_nurb(BlenderRNA *brna)
{
static EnumPropertyItem spline_interpolation_items[] = {
{BEZT_IPO_CONST, "LINEAR", "Linear", ""},
{BEZT_IPO_LIN, "CARDINAL", "Cardinal", ""},
{BEZT_IPO_BEZ, "BSPLINE", "BSpline", ""},
{BEZT_IPO_BEZ, "EASE", "Ease", ""},
{0, NULL, NULL, NULL}};
{BEZT_IPO_CONST, "LINEAR", 0, "Linear", ""},
{BEZT_IPO_LIN, "CARDINAL", 0, "Cardinal", ""},
{BEZT_IPO_BEZ, "BSPLINE", 0, "BSpline", ""},
{BEZT_IPO_BEZ, "EASE", 0, "Ease", ""},
{0, NULL, 0, NULL, NULL}};
StructRNA *srna;
PropertyRNA *prop;

13
source/blender/makesrna/intern/rna_define.c
View File

@ -976,6 +976,13 @@ void RNA_def_property_ui_text(PropertyRNA *prop, const char *name, const char *d
prop->description= description;
}
void RNA_def_property_ui_icon(PropertyRNA *prop, int icon, int consecutive)
{
prop->icon= icon;
if(consecutive)
prop->flag |= PROP_ICONS_CONSECUTIVE;
}
void RNA_def_property_ui_range(PropertyRNA *prop, double min, double max, double step, int precision)
{
StructRNA *srna= DefRNA.laststruct;
@ -2219,15 +2226,13 @@ int rna_parameter_size(PropertyRNA *parm)
case PROP_STRING:
return sizeof(char *);
case PROP_POINTER: {
PointerPropertyRNA *pprop= (PointerPropertyRNA*)parm;
#ifdef RNA_RUNTIME
if(pprop->type == &RNA_AnyType)
if(parm->flag & PROP_RNAPTR)
return sizeof(PointerRNA);
else
return sizeof(void *);
#else
if(strcmp((char*)pprop->type, "AnyType") == 0)
if(parm->flag & PROP_RNAPTR)
return sizeof(PointerRNA);
else
return sizeof(void *);

82
source/blender/makesrna/intern/rna_fcurve.c
View File

@ -35,15 +35,15 @@
#include "MEM_guardedalloc.h"
EnumPropertyItem fmodifier_type_items[] = {
{FMODIFIER_TYPE_NULL, "NULL", "Invalid", ""},
{FMODIFIER_TYPE_GENERATOR, "GENERATOR", "Generator", ""},
{FMODIFIER_TYPE_ENVELOPE, "ENVELOPE", "Envelope", ""},
{FMODIFIER_TYPE_CYCLES, "CYCLES", "Cycles", ""},
{FMODIFIER_TYPE_NOISE, "NOISE", "Noise", ""},
{FMODIFIER_TYPE_FILTER, "FILTER", "Filter", ""},
{FMODIFIER_TYPE_PYTHON, "PYTHON", "Python", ""},
{FMODIFIER_TYPE_LIMITS, "LIMITS", "Limits", ""},
{0, NULL, NULL, NULL}};
{FMODIFIER_TYPE_NULL, "NULL", 0, "Invalid", ""},
{FMODIFIER_TYPE_GENERATOR, "GENERATOR", 0, "Generator", ""},
{FMODIFIER_TYPE_ENVELOPE, "ENVELOPE", 0, "Envelope", ""},
{FMODIFIER_TYPE_CYCLES, "CYCLES", 0, "Cycles", ""},
{FMODIFIER_TYPE_NOISE, "NOISE", 0, "Noise", ""},
{FMODIFIER_TYPE_FILTER, "FILTER", 0, "Filter", ""},
{FMODIFIER_TYPE_PYTHON, "PYTHON", 0, "Python", ""},
{FMODIFIER_TYPE_LIMITS, "LIMITS", 0, "Limits", ""},
{0, NULL, 0, NULL, NULL}};
#ifdef RNA_RUNTIME
@ -220,11 +220,11 @@ static void rna_def_fmodifier_generator_common(StructRNA *srna)
PropertyRNA *prop;
static EnumPropertyItem prop_mode_items[] = {
{FCM_GENERATOR_POLYNOMIAL, "POLYNOMIAL", "Expanded Polynomial", ""},
{FCM_GENERATOR_POLYNOMIAL_FACTORISED, "POLYNOMIAL_FACTORISED", "Factorised Polynomial", ""},
{FCM_GENERATOR_FUNCTION, "FUNCTION", "Built-In Function", ""},
{FCM_GENERATOR_EXPRESSION, "EXPRESSION", "Expression", ""},
{0, NULL, NULL, NULL}};
{FCM_GENERATOR_POLYNOMIAL, "POLYNOMIAL", 0, "Expanded Polynomial", ""},
{FCM_GENERATOR_POLYNOMIAL_FACTORISED, "POLYNOMIAL_FACTORISED", 0, "Factorised Polynomial", ""},
{FCM_GENERATOR_FUNCTION, "FUNCTION", 0, "Built-In Function", ""},
{FCM_GENERATOR_EXPRESSION, "EXPRESSION", 0, "Expression", ""},
{0, NULL, 0, NULL, NULL}};
/* struct wrapping settings */
RNA_def_struct_sdna_from(srna, "FMod_Generator", "data");
@ -279,12 +279,12 @@ static void rna_def_fmodifier_generator_function(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_type_items[] = {
{0, "SIN", "Sine", ""},
{1, "COS", "Cosine", ""},
{2, "TAN", "Tangent", ""},
{3, "SQRT", "Square Root", ""},
{4, "LN", "Natural Logarithm", ""},
{0, NULL, NULL, NULL}};
{0, "SIN", 0, "Sine", ""},
{1, "COS", 0, "Cosine", ""},
{2, "TAN", 0, "Tangent", ""},
{3, "SQRT", 0, "Square Root", ""},
{4, "LN", 0, "Natural Logarithm", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "FModifierGenerator_Function", "FModifier");
@ -336,11 +336,11 @@ static void rna_def_fmodifier_cycles(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_type_items[] = {
{FCM_EXTRAPOLATE_NONE, "NONE", "No Cycles", "Don't do anything."},
{FCM_EXTRAPOLATE_CYCLIC, "REPEAT", "Repeat Motion", "Repeat keyframe range as-is."},
{FCM_EXTRAPOLATE_CYCLIC_OFFSET, "REPEAT_OFFSET", "Repeat with Offset", "Repeat keyframe range, but with offset based on gradient between values"},
{FCM_EXTRAPOLATE_MIRROR, "MIRROR", "Repeat Mirrored", "Alternate between forward and reverse playback of keyframe range"},
{0, NULL, NULL, NULL}};
{FCM_EXTRAPOLATE_NONE, "NONE", 0, "No Cycles", "Don't do anything."},
{FCM_EXTRAPOLATE_CYCLIC, "REPEAT", 0, "Repeat Motion", "Repeat keyframe range as-is."},
{FCM_EXTRAPOLATE_CYCLIC_OFFSET, "REPEAT_OFFSET", 0, "Repeat with Offset", "Repeat keyframe range, but with offset based on gradient between values"},
{FCM_EXTRAPOLATE_MIRROR, "MIRROR", 0, "Repeat Mirrored", "Alternate between forward and reverse playback of keyframe range"},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "FModifierCycles", "FModifier");
RNA_def_struct_ui_text(srna, "Cycles F-Curve Modifier", "Repeats the values of the modified F-Curve.");
@ -428,11 +428,11 @@ static void rna_def_fmodifier_noise(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_modification_items[] = {
{FCM_NOISE_MODIF_REPLACE, "REPLACE", "Replace", ""},
{FCM_NOISE_MODIF_ADD, "ADD", "Add", ""},
{FCM_NOISE_MODIF_SUBTRACT, "SUBTRACT", "Subtract", ""},
{FCM_NOISE_MODIF_MULTIPLY, "MULTIPLY", "Multiply", ""},
{0, NULL, NULL, NULL}};
{FCM_NOISE_MODIF_REPLACE, "REPLACE", 0, "Replace", ""},
{FCM_NOISE_MODIF_ADD, "ADD", 0, "Add", ""},
{FCM_NOISE_MODIF_SUBTRACT, "SUBTRACT", 0, "Subtract", ""},
{FCM_NOISE_MODIF_MULTIPLY, "MULTIPLY", 0, "Multiply", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "FModifierNoise", "FModifier");
RNA_def_struct_ui_text(srna, "Noise F-Curve Modifier", "Gives randomness to the modified F-Curve.");
@ -542,10 +542,10 @@ void rna_def_channeldriver(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_type_items[] = {
{DRIVER_TYPE_AVERAGE, "AVERAGE", "Averaged Value", ""},
{DRIVER_TYPE_PYTHON, "SCRIPTED", "Scripted Expression", ""},
{DRIVER_TYPE_ROTDIFF, "ROTDIFF", "Rotational Difference", ""},
{0, NULL, NULL, NULL}};
{DRIVER_TYPE_AVERAGE, "AVERAGE", 0, "Averaged Value", ""},
{DRIVER_TYPE_PYTHON, "SCRIPTED", 0, "Scripted Expression", ""},
{DRIVER_TYPE_ROTDIFF, "ROTDIFF", 0, "Rotational Difference", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "Driver", NULL);
RNA_def_struct_sdna(srna, "ChannelDriver");
@ -575,14 +575,14 @@ void rna_def_fcurve(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_mode_extend_items[] = {
{FCURVE_EXTRAPOLATE_CONSTANT, "CONSTANT", "Constant", ""},
{FCURVE_EXTRAPOLATE_LINEAR, "LINEAR", "Linear", ""},
{0, NULL, NULL, NULL}};
{FCURVE_EXTRAPOLATE_CONSTANT, "CONSTANT", 0, "Constant", ""},
{FCURVE_EXTRAPOLATE_LINEAR, "LINEAR", 0, "Linear", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem prop_mode_color_items[] = {
{FCURVE_COLOR_AUTO_RAINBOW, "AUTO_RAINBOW", "Automatic Rainbow", ""},
{FCURVE_COLOR_AUTO_RGB, "AUTO_RGB", "Automatic XYZ to RGB", ""},
{FCURVE_COLOR_CUSTOM, "CUSTOM", "User Defined", ""},
{0, NULL, NULL, NULL}};
{FCURVE_COLOR_AUTO_RAINBOW, "AUTO_RAINBOW", 0, "Automatic Rainbow", ""},
{FCURVE_COLOR_AUTO_RGB, "AUTO_RGB", 0, "Automatic XYZ to RGB", ""},
{FCURVE_COLOR_CUSTOM, "CUSTOM", 0, "User Defined", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "FCurve", NULL);
RNA_def_struct_ui_text(srna, "F-Curve", "F-Curve defining values of a period of time.");

52
source/blender/makesrna/intern/rna_fluidsim.c
View File

@ -64,10 +64,10 @@ static void rna_def_fluidsim_slip(StructRNA *srna)
PropertyRNA *prop;
static EnumPropertyItem slip_items[] = {
{OB_FSBND_NOSLIP, "NOSLIP", "No Slip", "Obstacle causes zero normal and tangential velocity (=sticky). Default for all. Only option for moving objects."},
{OB_FSBND_PARTSLIP, "PARTIALSLIP", "Partial Slip", "Mix between no-slip and free-slip. Non moving objects only!"},
{OB_FSBND_FREESLIP, "FREESLIP", "Free Slip", "Obstacle only causes zero normal velocity (=not sticky). Non moving objects only!"},
{0, NULL, NULL, NULL}};
{OB_FSBND_NOSLIP, "NOSLIP", 0, "No Slip", "Obstacle causes zero normal and tangential velocity (=sticky). Default for all. Only option for moving objects."},
{OB_FSBND_PARTSLIP, "PARTIALSLIP", 0, "Partial Slip", "Mix between no-slip and free-slip. Non moving objects only!"},
{OB_FSBND_FREESLIP, "FREESLIP", 0, "Free Slip", "Obstacle only causes zero normal velocity (=not sticky). Non moving objects only!"},
{0, NULL, 0, NULL, NULL}};
prop= RNA_def_property(srna, "slip_type", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_bitflag_sdna(prop, NULL, "typeFlags");
@ -86,17 +86,17 @@ static void rna_def_fluidsim_domain(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem quality_items[] = {
{OB_FSDOM_GEOM, "GEOMETRY", "Geometry", "Display geometry."},
{OB_FSDOM_PREVIEW, "PREVIEW", "Preview", "Display preview quality results."},
{OB_FSDOM_FINAL, "FINAL", "Final", "Display final quality results."},
{0, NULL, NULL, NULL}};
{OB_FSDOM_GEOM, "GEOMETRY", 0, "Geometry", "Display geometry."},
{OB_FSDOM_PREVIEW, "PREVIEW", 0, "Preview", "Display preview quality results."},
{OB_FSDOM_FINAL, "FINAL", 0, "Final", "Display final quality results."},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem viscosity_items[] = {
{1, "MANUAL", "Manual", "Manual viscosity settings."},
{2, "WATER", "Water", "Viscosity of 1.0 * 10^-6."},
{3, "OIL", "Oil", "Viscosity of 5.0 * 10^-5."},
{4, "HONEY", "Honey", "Viscosity of 2.0 * 10^-3."},
{0, NULL, NULL, NULL}};
{1, "MANUAL", 0, "Manual", "Manual viscosity settings."},
{2, "WATER", 0, "Water", "Viscosity of 1.0 * 10^-6."},
{3, "OIL", 0, "Oil", "Viscosity of 5.0 * 10^-5."},
{4, "HONEY", 0, "Honey", "Viscosity of 2.0 * 10^-3."},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "DomainFluidSettings", "FluidSettings");
RNA_def_struct_sdna(srna, "FluidsimSettings");
@ -217,10 +217,10 @@ static void rna_def_fluidsim_volume(StructRNA *srna)
PropertyRNA *prop;
static EnumPropertyItem volume_type_items[] = {
{1, "VOLUME", "Volume", "Use only the inner volume of the mesh."},
{2, "SHELL", "Shell", "Use only the outer shell of the mesh."},
{3, "BOTH", "Both", "Use both the inner volume and the outer shell of the mesh."},
{0, NULL, NULL, NULL}};
{1, "VOLUME", 0, "Volume", "Use only the inner volume of the mesh."},
{2, "SHELL", 0, "Shell", "Use only the outer shell of the mesh."},
{3, "BOTH", 0, "Both", "Use both the inner volume and the outer shell of the mesh."},
{0, NULL, 0, NULL, NULL}};
prop= RNA_def_property(srna, "volume_initialization", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_bitflag_sdna(prop, NULL, "volumeInitType");
@ -393,15 +393,15 @@ void RNA_def_fluidsim(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_fluid_type_items[] = {
{0, "NONE", "None", ""},
{OB_FLUIDSIM_DOMAIN, "DOMAIN", "Domain", "Bounding box of this object represents the computational domain of the fluid simulation."},
{OB_FLUIDSIM_FLUID, "FLUID", "Fluid", "Object represents a volume of fluid in the simulation."},
{OB_FLUIDSIM_OBSTACLE, "OBSTACLE", "Obstacle", "Object is a fixed obstacle."},
{OB_FLUIDSIM_INFLOW, "INFLOW", "Inflow", "Object adds fluid to the simulation."},
{OB_FLUIDSIM_OUTFLOW, "OUTFLOW", "Outflow", "Object removes fluid from the simulation."},
{OB_FLUIDSIM_PARTICLE, "PARTICLE", "Particle", "Object is made a particle system to display particles generated by a fluidsim domain object."},
{OB_FLUIDSIM_CONTROL, "CONTROL", "Control", "Object is made a fluid control mesh, which influences the fluid."},
{0, NULL, NULL, NULL}};
{0, "NONE", 0, "None", ""},
{OB_FLUIDSIM_DOMAIN, "DOMAIN", 0, "Domain", "Bounding box of this object represents the computational domain of the fluid simulation."},
{OB_FLUIDSIM_FLUID, "FLUID", 0, "Fluid", "Object represents a volume of fluid in the simulation."},
{OB_FLUIDSIM_OBSTACLE, "OBSTACLE", 0, "Obstacle", "Object is a fixed obstacle."},
{OB_FLUIDSIM_INFLOW, "INFLOW", 0, "Inflow", "Object adds fluid to the simulation."},
{OB_FLUIDSIM_OUTFLOW, "OUTFLOW", 0, "Outflow", "Object removes fluid from the simulation."},
{OB_FLUIDSIM_PARTICLE, "PARTICLE", 0, "Particle", "Object is made a particle system to display particles generated by a fluidsim domain object."},
{OB_FLUIDSIM_CONTROL, "CONTROL", 0, "Control", "Object is made a fluid control mesh, which influences the fluid."},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "FluidSettings", NULL);

56
source/blender/makesrna/intern/rna_image.c
View File

@ -32,10 +32,24 @@
#include "DNA_image_types.h"
#include "DNA_scene_types.h"
#include "BKE_context.h"
#include "BKE_image.h"
#ifdef RNA_RUNTIME
static void rna_Image_animated_update(bContext *C, PointerRNA *ptr)
{
Image *ima= (Image*)ptr->data;
int nr;
if(ima->flag & IMA_TWINANIM) {
nr= ima->xrep*ima->yrep;
if(ima->twsta>=nr) ima->twsta= 1;
if(ima->twend>=nr) ima->twend= nr-1;
if(ima->twsta>ima->twend) ima->twsta= 1;
}
}
#else
static void rna_def_imageuser(BlenderRNA *brna)
@ -89,27 +103,27 @@ static void rna_def_image(BlenderRNA *brna)
StructRNA *srna;
PropertyRNA *prop;
static const EnumPropertyItem prop_type_items[]= {
{IMA_TYPE_IMAGE, "IMAGE", "Image", ""},
{IMA_TYPE_MULTILAYER, "MULTILAYER", "Multilayer", ""},
{IMA_TYPE_UV_TEST, "UVTEST", "UV Test", ""},
{IMA_TYPE_R_RESULT, "RENDERRESULT", "Render Result", ""},
{IMA_TYPE_COMPOSITE, "COMPOSITING", "Compositing", ""},
{0, NULL, NULL, NULL}};
{IMA_TYPE_IMAGE, "IMAGE", 0, "Image", ""},
{IMA_TYPE_MULTILAYER, "MULTILAYER", 0, "Multilayer", ""},
{IMA_TYPE_UV_TEST, "UVTEST", 0, "UV Test", ""},
{IMA_TYPE_R_RESULT, "RENDERRESULT", 0, "Render Result", ""},
{IMA_TYPE_COMPOSITE, "COMPOSITING", 0, "Compositing", ""},
{0, NULL, 0, NULL, NULL}};
static const EnumPropertyItem prop_source_items[]= {
{IMA_SRC_FILE, "FILE", "File", "Single image file"},
{IMA_SRC_SEQUENCE, "SEQUENCE", "Sequence", "Multiple image files, as a sequence"},
{IMA_SRC_MOVIE, "MOVIE", "Movie", "Movie file"},
{IMA_SRC_GENERATED, "GENERATED", "Generated", "Generated image"},
{IMA_SRC_VIEWER, "VIEWER", "Viewer", "Compositing node viewer"},
{0, NULL, NULL, NULL}};
{IMA_SRC_FILE, "FILE", 0, "File", "Single image file"},
{IMA_SRC_SEQUENCE, "SEQUENCE", 0, "Sequence", "Multiple image files, as a sequence"},
{IMA_SRC_MOVIE, "MOVIE", 0, "Movie", "Movie file"},
{IMA_SRC_GENERATED, "GENERATED", 0, "Generated", "Generated image"},
{IMA_SRC_VIEWER, "VIEWER", 0, "Viewer", "Compositing node viewer"},
{0, NULL, 0, NULL, NULL}};
static const EnumPropertyItem prop_generated_type_items[]= {
{0, "BLANK", "Blank", "Generate a blank image"},
{1, "UVTESTGRID", "UV Test Grid", "Generated grid to test UV mappings"},
{0, NULL, NULL, NULL}};
{0, "BLANK", 0, "Blank", "Generate a blank image"},
{1, "UVTESTGRID", 0, "UV Test Grid", "Generated grid to test UV mappings"},
{0, NULL, 0, NULL, NULL}};
static const EnumPropertyItem prop_mapping_items[]= {
{0, "UV", "UV Coordinates", "Use UV coordinates for mapping the image"},
{IMA_REFLECT, "REFLECTION", "Reflection", "Use reflection mapping for mapping the image"},
{0, NULL, NULL, NULL}};
{0, "UV", 0, "UV Coordinates", "Use UV coordinates for mapping the image"},
{IMA_REFLECT, "REFLECTION", 0, "Reflection", "Use reflection mapping for mapping the image"},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "Image", "ID");
RNA_def_struct_ui_text(srna, "Image", "Image datablock referencing an external or packed image.");
@ -180,19 +194,21 @@ static void rna_def_image(BlenderRNA *brna)
RNA_def_property_ui_text(prop, "Display Aspect", "Display Aspect for this image, does not affect rendering.");
prop= RNA_def_property(srna, "animated", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* B_TWINANIM */
RNA_def_property_boolean_sdna(prop, NULL, "tpageflag", IMA_TWINANIM);
RNA_def_property_ui_text(prop, "Animated", "Use as animated texture in the game engine.");
RNA_def_property_update(prop, 0, "rna_Image_animated_update");
prop= RNA_def_property(srna, "animation_start", PROP_INT, PROP_NONE);
RNA_def_property_int_sdna(prop, NULL, "twsta");
RNA_def_property_range(prop, 0, 128);
RNA_def_property_ui_text(prop, "Animation Start", "Start frame of an animated texture.");
RNA_def_property_update(prop, 0, "rna_Image_animated_update");
prop= RNA_def_property(srna, "animation_end", PROP_INT, PROP_NONE);
RNA_def_property_int_sdna(prop, NULL, "twend");
RNA_def_property_range(prop, 0, 128);
RNA_def_property_ui_text(prop, "Animation End", "End frame of an animated texture.");
RNA_def_property_update(prop, 0, "rna_Image_animated_update");
prop= RNA_def_property(srna, "animation_speed", PROP_INT, PROP_NONE);
RNA_def_property_int_sdna(prop, NULL, "animspeed");
@ -200,8 +216,8 @@ static void rna_def_image(BlenderRNA *brna)
RNA_def_property_ui_text(prop, "Animation Speed", "Speed of the animation in frames per second.");
prop= RNA_def_property(srna, "tiles", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* B_SIMAGETILE */
RNA_def_property_boolean_sdna(prop, NULL, "tpageflag", IMA_TILES);
RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* image_tile_set */
RNA_def_property_ui_text(prop, "Tiles", "Use of tilemode for faces (default shift-LMB to pick the tile for selected faces).");
prop= RNA_def_property(srna, "tiles_x", PROP_INT, PROP_NONE);

2
source/blender/makesrna/intern/rna_internal_types.h
View File

@ -128,6 +128,8 @@ struct PropertyRNA {
const char *name;
/* single line description, displayed in the tooltip for example */
const char *description;
/* icon ID */
int icon;
/* property type as it appears to the outside */
PropertyType type;

8
source/blender/makesrna/intern/rna_key.c
View File

@ -277,10 +277,10 @@ static void rna_def_keyblock(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_keyblock_type_items[] = {
{KEY_LINEAR, "KEY_LINEAR", "Linear", ""},
{KEY_CARDINAL, "KEY_CARDINAL", "Cardinal", ""},
{KEY_BSPLINE, "KEY_BSPLINE", "BSpline", ""},
{0, NULL, NULL, NULL}};
{KEY_LINEAR, "KEY_LINEAR", 0, "Linear", ""},
{KEY_CARDINAL, "KEY_CARDINAL", 0, "Cardinal", ""},
{KEY_BSPLINE, "KEY_BSPLINE", 0, "BSpline", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "ShapeKey", NULL);
RNA_def_struct_ui_text(srna, "Shape Key", "Shape key in a shape keys datablock.");

132
source/blender/makesrna/intern/rna_lamp.c
View File

@ -91,10 +91,10 @@ static void rna_def_lamp_mtex(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_texture_coordinates_items[] = {
{TEXCO_GLOB, "GLOBAL", "Global", "Uses global coordinates for the texture coordinates."},
{TEXCO_VIEW, "VIEW", "View", "Uses view coordinates for the texture coordinates."},
{TEXCO_OBJECT, "OBJECT", "Object", "Uses linked object's coordinates for texture coordinates."},
{0, NULL, NULL, NULL}};
{TEXCO_GLOB, "GLOBAL", 0, "Global", "Uses global coordinates for the texture coordinates."},
{TEXCO_VIEW, "VIEW", 0, "View", "Uses view coordinates for the texture coordinates."},
{TEXCO_OBJECT, "OBJECT", 0, "Object", "Uses linked object's coordinates for texture coordinates."},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "LampTextureSlot", "TextureSlot");
RNA_def_struct_sdna(srna, "MTex");
@ -126,29 +126,29 @@ static void rna_def_lamp_sky_settings(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_skycolorspace_items[] = {
{0, "SMPTE", "SMPTE", ""},
{1, "REC709", "REC709", ""},
{2, "CIE", "CIE", ""},
{0, NULL, NULL, NULL}};
{0, "SMPTE", 0, "SMPTE", ""},
{1, "REC709", 0, "REC709", ""},
{2, "CIE", 0, "CIE", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem prop_blendmode_items[] = {
{0, "MIX", "Mix", ""},
{1, "ADD", "Add", ""},
{2, "MULTIPLY", "Multiply", ""},
{3, "SUBTRACT", "Subtract", ""},
{4, "SCREEN", "Screen", ""},
{5, "DIVIDE", "Divide", ""},
{6, "DIFFERENCE", "Difference", ""},
{7, "DARKEN", "Darken", ""},
{8, "LIGHTEN", "Lighten", ""},
{9, "OVERLAY", "Overlay", ""},
{10, "DODGE", "Dodge", ""},
{11, "BURN", "Burn", ""},
{12, "HUE", "Hue", ""},
{13, "SATURATION", "Saturation", ""},
{14, "VALUE", "Value", ""},
{15, "COLOR", "Color", ""},
{0, NULL, NULL, NULL}};
{0, "MIX", 0, "Mix", ""},
{1, "ADD", 0, "Add", ""},
{2, "MULTIPLY", 0, "Multiply", ""},
{3, "SUBTRACT", 0, "Subtract", ""},
{4, "SCREEN", 0, "Screen", ""},
{5, "DIVIDE", 0, "Divide", ""},
{6, "DIFFERENCE", 0, "Difference", ""},
{7, "DARKEN", 0, "Darken", ""},
{8, "LIGHTEN", 0, "Lighten", ""},
{9, "OVERLAY", 0, "Overlay", ""},
{10, "DODGE", 0, "Dodge", ""},
{11, "BURN", 0, "Burn", ""},
{12, "HUE", 0, "Hue", ""},
{13, "SATURATION", 0, "Saturation", ""},
{14, "VALUE", 0, "Value", ""},
{15, "COLOR", 0, "Color", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "LampSkySettings", NULL);
RNA_def_struct_sdna(srna, "Lamp");
@ -253,12 +253,12 @@ static void rna_def_lamp(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_type_items[] = {
{LA_LOCAL, "POINT", "Point", "Omnidirectional point light source."},
{LA_SUN, "SUN", "Sun", "Constant direction parallel ray light source."},
{LA_SPOT, "SPOT", "Spot", "Directional cone light source."},
{LA_HEMI, "HEMI", "Hemi", "180 degree constant light source."},
{LA_AREA, "AREA", "Area", "Directional area light source."},
{0, NULL, NULL, NULL}};
{LA_LOCAL, "POINT", 0, "Point", "Omnidirectional point light source."},
{LA_SUN, "SUN", 0, "Sun", "Constant direction parallel ray light source."},
{LA_SPOT, "SPOT", 0, "Spot", "Directional cone light source."},
{LA_HEMI, "HEMI", 0, "Hemi", "180 degree constant light source."},
{LA_AREA, "AREA", 0, "Area", "Directional area light source."},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "Lamp", "ID");
RNA_def_struct_refine_func(srna, "rna_Lamp_refine");
@ -322,12 +322,12 @@ static void rna_def_lamp_falloff(StructRNA *srna)
PropertyRNA *prop;
static EnumPropertyItem prop_fallofftype_items[] = {
{LA_FALLOFF_CONSTANT, "CONSTANT", "Constant", ""},
{LA_FALLOFF_INVLINEAR, "INVERSE_LINEAR", "Inverse Linear", ""},
{LA_FALLOFF_INVSQUARE, "INVERSE_SQUARE", "Inverse Square", ""},
{LA_FALLOFF_CURVE, "CUSTOM_CURVE", "Custom Curve", ""},
{LA_FALLOFF_SLIDERS, "LINEAR_QUADRATIC_WEIGHTED", "Lin/Quad Weighted", ""},
{0, NULL, NULL, NULL}};
{LA_FALLOFF_CONSTANT, "CONSTANT", 0, "Constant", ""},
{LA_FALLOFF_INVLINEAR, "INVERSE_LINEAR", 0, "Inverse Linear", ""},
{LA_FALLOFF_INVSQUARE, "INVERSE_SQUARE", 0, "Inverse Square", ""},
{LA_FALLOFF_CURVE, "CUSTOM_CURVE", 0, "Custom Curve", ""},
{LA_FALLOFF_SLIDERS, "LINEAR_QUADRATIC_WEIGHTED", 0, "Lin/Quad Weighted", ""},
{0, NULL, 0, NULL, NULL}};
prop= RNA_def_property(srna, "falloff_type", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_items(prop, prop_fallofftype_items);
@ -362,26 +362,26 @@ static void rna_def_lamp_shadow(StructRNA *srna, int spot, int area)
PropertyRNA *prop;
static EnumPropertyItem prop_shadow_items[] = {
{0, "NOSHADOW", "No Shadow", ""},
{LA_SHAD_RAY, "RAY_SHADOW", "Ray Shadow", "Use ray tracing for shadow."},
{0, NULL, NULL, NULL}};
{0, "NOSHADOW", 0, "No Shadow", ""},
{LA_SHAD_RAY, "RAY_SHADOW", 0, "Ray Shadow", "Use ray tracing for shadow."},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem prop_spot_shadow_items[] = {
{0, "NOSHADOW", "No Shadow", ""},
{LA_SHAD_BUF, "BUFFER_SHADOW", "Buffer Shadow", "Lets spotlight produce shadows using shadow buffer."},
{LA_SHAD_RAY, "RAY_SHADOW", "Ray Shadow", "Use ray tracing for shadow."},
{0, NULL, NULL, NULL}};
{0, "NOSHADOW", 0, "No Shadow", ""},
{LA_SHAD_BUF, "BUFFER_SHADOW", 0, "Buffer Shadow", "Lets spotlight produce shadows using shadow buffer."},
{LA_SHAD_RAY, "RAY_SHADOW", 0, "Ray Shadow", "Use ray tracing for shadow."},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem prop_ray_sampling_method_items[] = {
{LA_SAMP_HALTON, "ADAPTIVE_QMC", "Adaptive QMC", ""},
{LA_SAMP_HAMMERSLEY, "CONSTANT_QMC", "Constant QMC", ""},
{0, NULL, NULL, NULL}};
{LA_SAMP_HALTON, "ADAPTIVE_QMC", 0, "Adaptive QMC", ""},
{LA_SAMP_HAMMERSLEY, "CONSTANT_QMC", 0, "Constant QMC", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem prop_spot_ray_sampling_method_items[] = {
{LA_SAMP_HALTON, "ADAPTIVE_QMC", "Adaptive QMC", ""},
{LA_SAMP_HAMMERSLEY, "CONSTANT_QMC", "Constant QMC", ""},
{LA_SAMP_CONSTANT, "CONSTANT_JITTERED", "Constant Jittered", ""},
{0, NULL, NULL, NULL}};
{LA_SAMP_HALTON, "ADAPTIVE_QMC", 0, "Adaptive QMC", ""},
{LA_SAMP_HAMMERSLEY, "CONSTANT_QMC", 0, "Constant QMC", ""},
{LA_SAMP_CONSTANT, "CONSTANT_JITTERED", 0, "Constant Jittered", ""},
{0, NULL, 0, NULL, NULL}};
prop= RNA_def_property(srna, "shadow_method", PROP_ENUM, PROP_NONE);
@ -457,9 +457,9 @@ static void rna_def_area_lamp(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_areashape_items[] = {
{LA_AREA_SQUARE, "SQUARE", "Square", ""},
{LA_AREA_RECT, "RECTANGLE", "Rectangle", ""},
{0, NULL, NULL, NULL}};
{LA_AREA_SQUARE, "SQUARE", 0, "Square", ""},
{LA_AREA_RECT, "RECTANGLE", 0, "Rectangle", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "AreaLamp", "Lamp");
RNA_def_struct_sdna(srna, "Lamp");
@ -513,22 +513,22 @@ static void rna_def_spot_lamp(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_shadbuftype_items[] = {
{LA_SHADBUF_REGULAR , "REGULAR", "Classical", "Classic shadow buffer."},
{LA_SHADBUF_HALFWAY, "HALFWAY", "Classic-Halfway", "Regular buffer, averaging the closest and 2nd closest Z value to reducing bias artifaces."},
{LA_SHADBUF_IRREGULAR, "IRREGULAR", "Irregular", "Irregular buffer produces sharp shadow always, but it doesn't show up for raytracing."},
{0, NULL, NULL, NULL}};
{LA_SHADBUF_REGULAR , "REGULAR", 0, "Classical", "Classic shadow buffer."},
{LA_SHADBUF_HALFWAY, "HALFWAY", 0, "Classic-Halfway", "Regular buffer, averaging the closest and 2nd closest Z value to reducing bias artifaces."},
{LA_SHADBUF_IRREGULAR, "IRREGULAR", 0, "Irregular", "Irregular buffer produces sharp shadow always, but it doesn't show up for raytracing."},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem prop_shadbuffiltertype_items[] = {
{LA_SHADBUF_BOX , "BOX", "Box", "Apply the Box filter to shadow buffer samples."},
{LA_SHADBUF_TENT, "TENT", "Tent", "Apply the Tent Filter to shadow buffer samples."},
{LA_SHADBUF_GAUSS, "GAUSS", "Gauss", "Apply the Gauss filter to shadow buffer samples."},
{0, NULL, NULL, NULL}};
{LA_SHADBUF_BOX , "BOX", 0, "Box", "Apply the Box filter to shadow buffer samples."},
{LA_SHADBUF_TENT, "TENT", 0, "Tent", "Apply the Tent Filter to shadow buffer samples."},
{LA_SHADBUF_GAUSS, "GAUSS", 0, "Gauss", "Apply the Gauss filter to shadow buffer samples."},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem prop_numbuffer_items[] = {
{1, "BUFFERS_1", "1", "Only one buffer rendered."},
{4, "BUFFERS_4", "4", "Renders 4 buffers for better AA, this quadruples memory usage."},
{9, "BUFFERS_9", "9", "Renders 9 buffers for better AA, this uses nine times more memory."},
{0, NULL, NULL, NULL}};
{1, "BUFFERS_1", 0, "1", "Only one buffer rendered."},
{4, "BUFFERS_4", 0, "4", "Renders 4 buffers for better AA, this quadruples memory usage."},
{9, "BUFFERS_9", 0, "9", "Renders 9 buffers for better AA, this uses nine times more memory."},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "SpotLamp", "Lamp");
RNA_def_struct_sdna(srna, "Lamp");

8
source/blender/makesrna/intern/rna_lattice.c
View File

@ -110,10 +110,10 @@ static void rna_def_lattice(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_keyblock_type_items[] = {
{KEY_LINEAR, "KEY_LINEAR", "Linear", ""},
{KEY_CARDINAL, "KEY_CARDINAL", "Cardinal", ""},
{KEY_BSPLINE, "KEY_BSPLINE", "BSpline", ""},
{0, NULL, NULL, NULL}};
{KEY_LINEAR, "KEY_LINEAR", 0, "Linear", ""},
{KEY_CARDINAL, "KEY_CARDINAL", 0, "Cardinal", ""},
{KEY_BSPLINE, "KEY_BSPLINE", 0, "BSpline", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "Lattice", "ID");
RNA_def_struct_ui_text(srna, "Lattice", "Lattice datablock defining a grid for deforming other objects.");

202
source/blender/makesrna/intern/rna_material.c
View File

@ -112,6 +112,35 @@ static void rna_MaterialStrand_end_size_range(PointerRNA *ptr, float *min, float
}
}
static int rna_MaterialTextureSlot_enabled_get(PointerRNA *ptr)
{
Material *ma= (Material*)ptr->id.data;
MTex *mtex= (MTex*)ptr->data;
int a;
for(a=0; a<MAX_MTEX; a++)
if(ma->mtex[a] == mtex)
return (ma->septex & (1<<a)) == 0;
return 0;
}
static void rna_MaterialTextureSlot_enabled_set(PointerRNA *ptr, int value)
{
Material *ma= (Material*)ptr->id.data;
MTex *mtex= (MTex*)ptr->data;
int a;
for(a=0; a<MAX_MTEX; a++) {
if(ma->mtex[a] == mtex) {
if(value)
ma->septex &= ~(1<<a);
else
ma->septex |= (1<<a);
}
}
}
#else
static void rna_def_material_mtex(BlenderRNA *brna)
@ -120,54 +149,54 @@ static void rna_def_material_mtex(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_texture_coordinates_items[] = {
{TEXCO_GLOB, "GLOBAL", "Global", "Uses global coordinates for the texture coordinates."},
{TEXCO_OBJECT, "OBJECT", "Object", "Uses linked object's coordinates for texture coordinates."},
{TEXCO_UV, "UV", "UV", "Uses UV coordinates for texture coordinates."},
{TEXCO_ORCO, "ORCO", "Generated", "Uses the original undeformed coordinates of the object."},
{TEXCO_STRAND, "STRAND", "Strand", "Uses normalized strand texture coordinate (1D)."},
{TEXCO_STICKY, "STICKY", "Sticky", "Uses mesh's sticky coordinates for the texture coordinates."},
{TEXCO_WINDOW, "WINDOW", "Window", "Uses screen coordinates as texture coordinates."},
{TEXCO_NORM, "NORMAL", "Normal", "Uses normal vector as texture coordinates."},
{TEXCO_REFL, "REFLECTION", "Reflection", "Uses reflection vector as texture coordinates."},
{TEXCO_STRESS, "STRESS", "Stress", "Uses the difference of edge lengths compared to original coordinates of the mesh."},
{TEXCO_SPEED, "TANGENT", "Tangent", "Uses the optional tangent vector as texture coordinates."},
{TEXCO_GLOB, "GLOBAL", 0, "Global", "Uses global coordinates for the texture coordinates."},
{TEXCO_OBJECT, "OBJECT", 0, "Object", "Uses linked object's coordinates for texture coordinates."},
{TEXCO_UV, "UV", 0, "UV", "Uses UV coordinates for texture coordinates."},
{TEXCO_ORCO, "ORCO", 0, "Generated", "Uses the original undeformed coordinates of the object."},
{TEXCO_STRAND, "STRAND", 0, "Strand", "Uses normalized strand texture coordinate (1D)."},
{TEXCO_STICKY, "STICKY", 0, "Sticky", "Uses mesh's sticky coordinates for the texture coordinates."},
{TEXCO_WINDOW, "WINDOW", 0, "Window", "Uses screen coordinates as texture coordinates."},
{TEXCO_NORM, "NORMAL", 0, "Normal", "Uses normal vector as texture coordinates."},
{TEXCO_REFL, "REFLECTION", 0, "Reflection", "Uses reflection vector as texture coordinates."},
{TEXCO_STRESS, "STRESS", 0, "Stress", "Uses the difference of edge lengths compared to original coordinates of the mesh."},
{TEXCO_TANGENT, "TANGENT", 0, "Tangent", "Uses the optional tangent vector as texture coordinates."},
{0, NULL, NULL, NULL}};
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem prop_mapping_items[] = {
{MTEX_FLAT, "FLAT", "Flat", "Maps X and Y coordinates directly."},
{MTEX_CUBE, "CUBE", "Cube", "Maps using the normal vector."},
{MTEX_TUBE, "TUBE", "Tube", "Maps with Z as central axis."},
{MTEX_SPHERE, "SPHERE", "Sphere", "Maps with Z as central axis."},
{0, NULL, NULL, NULL}};
{MTEX_FLAT, "FLAT", 0, "Flat", "Maps X and Y coordinates directly."},
{MTEX_CUBE, "CUBE", 0, "Cube", "Maps using the normal vector."},
{MTEX_TUBE, "TUBE", 0, "Tube", "Maps with Z as central axis."},
{MTEX_SPHERE, "SPHERE", 0, "Sphere", "Maps with Z as central axis."},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem prop_x_mapping_items[] = {
{0, "NONE", "None", ""},
{1, "X", "X", ""},
{2, "Y", "Y", ""},
{3, "Z", "Z", ""},
{0, NULL, NULL, NULL}};
{0, "NONE", 0, "None", ""},
{1, "X", 0, "X", ""},
{2, "Y", 0, "Y", ""},
{3, "Z", 0, "Z", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem prop_y_mapping_items[] = {
{0, "NONE", "None", ""},
{1, "X", "X", ""},
{2, "Y", "Y", ""},
{3, "Z", "Z", ""},
{0, NULL, NULL, NULL}};
{0, "NONE", 0, "None", ""},
{1, "X", 0, "X", ""},
{2, "Y", 0, "Y", ""},
{3, "Z", 0, "Z", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem prop_z_mapping_items[] = {
{0, "NONE", "None", ""},
{1, "X", "X", ""},
{2, "Y", "Y", ""},
{3, "Z", "Z", ""},
{0, NULL, NULL, NULL}};
{0, "NONE", 0, "None", ""},
{1, "X", 0, "X", ""},
{2, "Y", 0, "Y", ""},
{3, "Z", 0, "Z", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem prop_normal_map_space_items[] = {
{MTEX_NSPACE_CAMERA, "CAMERA", "Camera", ""},
{MTEX_NSPACE_WORLD, "WORLD", "World", ""},
{MTEX_NSPACE_OBJECT, "OBJECT", "Object", ""},
{MTEX_NSPACE_TANGENT, "TANGENT", "Tangent", ""},
{0, NULL, NULL, NULL}};
{MTEX_NSPACE_CAMERA, "CAMERA", 0, "Camera", ""},
{MTEX_NSPACE_WORLD, "WORLD", 0, "World", ""},
{MTEX_NSPACE_OBJECT, "OBJECT", 0, "Object", ""},
{MTEX_NSPACE_TANGENT, "TANGENT", 0, "Tangent", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "MaterialTextureSlot", "TextureSlot");
RNA_def_struct_sdna(srna, "MTex");
@ -287,6 +316,12 @@ static void rna_def_material_mtex(BlenderRNA *brna)
RNA_def_property_float_sdna(prop, NULL, "warpfac");
RNA_def_property_range(prop, 0, 1);
RNA_def_property_ui_text(prop, "Warp Factor", "Amount texture affects color values.");
prop= RNA_def_property(srna, "enabled", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(prop, "rna_MaterialTextureSlot_enabled_get", "rna_MaterialTextureSlot_enabled_set");
RNA_def_property_ui_text(prop, "Enabled", "Enable this material texture slot.");
RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
}
static void rna_def_material_colors(StructRNA *srna)
@ -333,12 +368,12 @@ static void rna_def_material_diffuse(StructRNA *srna)
PropertyRNA *prop;
static EnumPropertyItem prop_diff_shader_items[] = {
{MA_DIFF_LAMBERT, "LAMBERT", "Lambert", ""},
{MA_DIFF_ORENNAYAR, "OREN_NAYAR", "Oren-Nayar", ""},
{MA_DIFF_TOON, "TOON", "Toon", ""},
{MA_DIFF_MINNAERT, "MINNAERT", "Minnaert", ""},
{MA_DIFF_FRESNEL, "FRESNEL", "Fresnel", ""},
{0, NULL, NULL, NULL}};
{MA_DIFF_LAMBERT, "LAMBERT", 0, "Lambert", ""},
{MA_DIFF_ORENNAYAR, "OREN_NAYAR", 0, "Oren-Nayar", ""},
{MA_DIFF_TOON, "TOON", 0, "Toon", ""},
{MA_DIFF_MINNAERT, "MINNAERT", 0, "Minnaert", ""},
{MA_DIFF_FRESNEL, "FRESNEL", 0, "Fresnel", ""},
{0, NULL, 0, NULL, NULL}};
prop= RNA_def_property(srna, "diffuse_shader", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "diff_shader");
@ -356,12 +391,29 @@ static void rna_def_material_diffuse(StructRNA *srna)
RNA_def_property_range(prop, 0.0f, 3.14f);
RNA_def_property_ui_text(prop, "Roughness", "Oren-Nayar Roughness");
RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
prop= RNA_def_property(srna, "params1_4", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, NULL, "param");
RNA_def_property_array(prop, 4);
prop= RNA_def_property(srna, "diffuse_toon_size", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, NULL, "param[0]");
RNA_def_property_range(prop, 0.0f, 3.14f);
RNA_def_property_ui_text(prop, "Diffuse Toon Size", "Size of diffuse toon area.");
RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
prop= RNA_def_property(srna, "diffuse_toon_smooth", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, NULL, "param[1]");
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(prop, "Diffuse Toon Smooth", "Smoothness of diffuse toon area.");
RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
prop= RNA_def_property(srna, "diffuse_fresnel", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, NULL, "param[1]");
RNA_def_property_range(prop, 0.0f, 5.0f);
RNA_def_property_ui_text(prop, "Params 1-4", "Parameters used for diffuse and specular Toon, and diffuse Fresnel shaders. Check documentation for details.");
RNA_def_property_ui_text(prop, "Diffuse Fresnel", "Power of Fresnel.");
RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
prop= RNA_def_property(srna, "diffuse_fresnel_factor", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, NULL, "param[0]");
RNA_def_property_range(prop, 0.0f, 5.0f);
RNA_def_property_ui_text(prop, "Diffuse Fresnel Factor", "Blending factor of Frensel.");
RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
prop= RNA_def_property(srna, "darkness", PROP_FLOAT, PROP_NONE);
@ -376,9 +428,9 @@ static void rna_def_material_raymirror(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_fadeto_mir_items[] = {
{MA_RAYMIR_FADETOSKY, "FADE_TO_SKY", "Fade to Sky Color", ""},
{MA_RAYMIR_FADETOMAT, "FADE_TO_MATERIAL", "Fade to Material Color", ""},
{0, NULL, NULL, NULL}};
{MA_RAYMIR_FADETOSKY, "FADE_TO_SKY", 0, "Fade to Sky Color", ""},
{MA_RAYMIR_FADETOMAT, "FADE_TO_MATERIAL", 0, "Fade to Material Color", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "MaterialRaytraceMirror", NULL);
RNA_def_struct_sdna(srna, "Material");
@ -736,12 +788,12 @@ void rna_def_material_specularity(StructRNA *srna)
PropertyRNA *prop;
static EnumPropertyItem prop_spec_shader_items[] = {
{MA_SPEC_COOKTORR, "COOKTORR", "CookTorr", ""},
{MA_SPEC_PHONG, "PHONG", "Phong", ""},
{MA_SPEC_BLINN, "BLINN", "Blinn", ""},
{MA_SPEC_TOON, "TOON", "Toon", ""},
{MA_SPEC_WARDISO, "WARDISO", "WardIso", ""},
{0, NULL, NULL, NULL}};
{MA_SPEC_COOKTORR, "COOKTORR", 0, "CookTorr", ""},
{MA_SPEC_PHONG, "PHONG", 0, "Phong", ""},
{MA_SPEC_BLINN, "BLINN", 0, "Blinn", ""},
{MA_SPEC_TOON, "TOON", 0, "Toon", ""},
{MA_SPEC_WARDISO, "WARDISO", 0, "WardIso", ""},
{0, NULL, 0, NULL, NULL}};
prop= RNA_def_property(srna, "spec_shader", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "spec_shader");
@ -749,27 +801,40 @@ void rna_def_material_specularity(StructRNA *srna)
RNA_def_property_ui_text(prop, "Specular Shader Model", "");
RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
prop= RNA_def_property(srna, "specularity", PROP_FLOAT, PROP_NONE);
prop= RNA_def_property(srna, "specular_reflection", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, NULL, "spec");
RNA_def_property_range(prop, 0, 1);
RNA_def_property_ui_text(prop, "Specularity Intensity", "");
RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
/* XXX: this field is also used for Halo hardness. should probably be fixed in DNA */
/* I guess it's fine. Specular is disabled when mat type is Halo. --DingTo */
/* NOTE: "har", "param", etc are used for multiple purposes depending on
* settings. This should be fixed in DNA once, for RNA we just expose them
* multiple times, which may give somewhat strange changes in the outliner,
* but in the UI they are never visible at the same time. */
prop= RNA_def_property(srna, "specular_hardness", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, NULL, "har");
RNA_def_property_range(prop, 1, 511);
RNA_def_property_ui_text(prop, "Specular Hardness", "");
RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
prop= RNA_def_property(srna, "specular_refraction", PROP_FLOAT, PROP_NONE);
prop= RNA_def_property(srna, "specular_ior", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, NULL, "refrac");
RNA_def_property_range(prop, 1, 10);
RNA_def_property_ui_text(prop, "Specular IOR", "");
RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
/* XXX: evil "param" field also does specular stuff */
prop= RNA_def_property(srna, "specular_toon_size", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, NULL, "param[2]");
RNA_def_property_range(prop, 0.0f, 1.53f);
RNA_def_property_ui_text(prop, "Specular Toon Size", "Size of specular toon area.");
RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
prop= RNA_def_property(srna, "specular_toon_smooth", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, NULL, "param[3]");
RNA_def_property_range(prop, 0.0f, 1.0f);
RNA_def_property_ui_text(prop, "Specular Toon Smooth", "Ssmoothness of specular toon area.");
RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
prop= RNA_def_property(srna, "specular_slope", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, NULL, "rms");
@ -851,10 +916,10 @@ void RNA_def_material(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_type_items[] = {
{MA_TYPE_SURFACE, "SURFACE", "Surface", "Render object as a surface."},
{MA_TYPE_VOLUME, "VOLUME", "Volume", "Render object as a volume."},
{MA_TYPE_HALO, "HALO", "Halo", "Render object as halo particles."},
{0, NULL, NULL, NULL}};
{MA_TYPE_SURFACE, "SURFACE", 0, "Surface", "Render object as a surface."},
{MA_TYPE_VOLUME, "VOLUME", 0, "Volume", "Render object as a volume."},
{MA_TYPE_HALO, "HALO", 0, "Halo", "Render object as halo particles."},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "Material", "ID");
RNA_def_struct_ui_text(srna, "Material", "Material datablock to defined the appearance of geometric objects for rendering.");
@ -876,6 +941,7 @@ void RNA_def_material(BlenderRNA *brna)
prop= RNA_def_property(srna, "emit", PROP_FLOAT, PROP_NONE);
RNA_def_property_range(prop, 0, 2);
RNA_def_property_ui_text(prop, "Emit", "Amount of light to emit.");
RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
prop= RNA_def_property(srna, "translucency", PROP_FLOAT, PROP_NONE);
RNA_def_property_range(prop, 0, 1);
@ -885,10 +951,12 @@ void RNA_def_material(BlenderRNA *brna)
prop= RNA_def_property(srna, "cubic", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "shade_flag", MA_CUBIC);
RNA_def_property_ui_text(prop, "Cubic Interpolation", "Use cubic interpolation for diffuse values, for smoother transitions.");
RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
prop= RNA_def_property(srna, "object_color", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "shade_flag", MA_OBCOLOR);
RNA_def_property_ui_text(prop, "Object Color", "Modulate the result with a per-object color.");
RNA_def_property_update(prop, NC_MATERIAL|ND_SHADING, NULL);
prop= RNA_def_property(srna, "shadow_ray_bias", PROP_FLOAT, PROP_NONE);
RNA_def_property_float_sdna(prop, NULL, "sbias");
@ -1054,8 +1122,6 @@ void RNA_def_material(BlenderRNA *brna)
RNA_def_property_pointer_sdna(prop, NULL, "scriptlink");
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_ui_text(prop, "Script Link", "Scripts linked to this material.");
/* XXX: does Material.septex get RNA? */
rna_def_material_colors(srna);
rna_def_material_diffuse(srna);

14
source/blender/makesrna/intern/rna_mesh.c
View File

@ -734,11 +734,11 @@ static void rna_def_mtface(BlenderRNA *brna)
StructRNA *srna;
PropertyRNA *prop;
static const EnumPropertyItem transp_items[]= {
{TF_SOLID, "OPAQUE", "Opaque", "Render color of textured face as color"},
{TF_ADD, "ADD", "Add", "Render face transparent and add color of face"},
{TF_ALPHA, "ALPHA", "Alpha", "Render polygon transparent, depending on alpha channel of the texture"},
{TF_CLIP, "CLIPALPHA", "Clip Alpha", "Use the images alpha values clipped with no blending (binary alpha)"},
{0, NULL, NULL, NULL}};
{TF_SOLID, "OPAQUE", 0, "Opaque", "Render color of textured face as color"},
{TF_ADD, "ADD", 0, "Add", "Render face transparent and add color of face"},
{TF_ALPHA, "ALPHA", 0, "Alpha", "Render polygon transparent, depending on alpha channel of the texture"},
{TF_CLIP, "CLIPALPHA", 0, "Clip Alpha", "Use the images alpha values clipped with no blending (binary alpha)"},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "MeshTextureFaceLayer", NULL);
RNA_def_struct_ui_text(srna, "Mesh Texture Face Layer", "Layer of texture faces in a Mesh datablock.");
@ -779,10 +779,6 @@ static void rna_def_mtface(BlenderRNA *brna)
RNA_def_property_boolean_sdna(prop, NULL, "mode", TF_TEX);
RNA_def_property_ui_text(prop, "Tex", "Render face with texture");
prop= RNA_def_property(srna, "tiles", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "mode", TF_TILES);
RNA_def_property_ui_text(prop, "Tiles", "Use tilemode for face");
prop= RNA_def_property(srna, "light", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "mode", TF_LIGHT);
RNA_def_property_ui_text(prop, "Light", "Use light for face");

22
source/blender/makesrna/intern/rna_meta.c
View File

@ -47,12 +47,12 @@ void rna_def_metaelement(BlenderRNA *brna)
StructRNA *srna;
PropertyRNA *prop;
static EnumPropertyItem prop_type_items[] = {
{MB_BALL, "BALL", "Ball", ""},
{MB_TUBE, "TUBE", "Tube", ""},
{MB_PLANE, "PLANE", "Plane", ""},
{MB_ELIPSOID, "ELLIPSOID", "Ellipsoid", ""}, // NOTE: typo at original definition!
{MB_CUBE, "CUBE", "Cube", ""},
{0, NULL, NULL, NULL}};
{MB_BALL, "BALL", 0, "Ball", ""},
{MB_TUBE, "TUBE", 0, "Tube", ""},
{MB_PLANE, "PLANE", 0, "Plane", ""},
{MB_ELIPSOID, "ELLIPSOID", 0, "Ellipsoid", ""}, // NOTE: typo at original definition!
{MB_CUBE, "CUBE", 0, "Cube", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "MetaElement", NULL);
RNA_def_struct_sdna(srna, "MetaElem");
@ -105,11 +105,11 @@ void rna_def_metaball(BlenderRNA *brna)
StructRNA *srna;
PropertyRNA *prop;
static EnumPropertyItem prop_update_items[] = {
{MB_UPDATE_ALWAYS, "UPDATE_ALWAYS", "Always", "While editing, update metaball always."},
{MB_UPDATE_HALFRES, "HALFRES", "Half Resolution", "While editing, update metaball in half resolution."},
{MB_UPDATE_FAST, "FAST", "Fast", "While editing, update metaball without polygonization."},
{MB_UPDATE_NEVER, "NEVER", "Never", "While editing, don't update metaball at all."},
{0, NULL, NULL, NULL}};
{MB_UPDATE_ALWAYS, "UPDATE_ALWAYS", 0, "Always", "While editing, update metaball always."},
{MB_UPDATE_HALFRES, "HALFRES", 0, "Half Resolution", "While editing, update metaball in half resolution."},
{MB_UPDATE_FAST, "FAST", 0, "Fast", "While editing, update metaball without polygonization."},
{MB_UPDATE_NEVER, "NEVER", 0, "Never", "While editing, don't update metaball at all."},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "MetaBall", "ID");
RNA_def_struct_ui_text(srna, "MetaBall", "Metaball datablock to defined blobby surfaces.");

176
source/blender/makesrna/intern/rna_modifier.c
View File

@ -41,36 +41,36 @@
#include "WM_types.h"
EnumPropertyItem modifier_type_items[] ={
{eModifierType_Armature, "ARMATURE", "Armature", ""},
{eModifierType_Array, "ARRAY", "Array", ""},
{eModifierType_Bevel, "BEVEL", "Bevel", ""},
{eModifierType_Boolean, "BOOLEAN", "Boolean", ""},
{eModifierType_Build, "BUILD", "Build", ""},
{eModifierType_Cast, "CAST", "Cast", ""},
{eModifierType_Cloth, "CLOTH", "Cloth", ""},
{eModifierType_Collision, "COLLISION", "Collision", ""},
{eModifierType_Curve, "CURVE", "Curve", ""},
{eModifierType_Decimate, "DECIMATE", "Decimate", ""},
{eModifierType_Displace, "DISPLACE", "Displace", ""},
{eModifierType_EdgeSplit, "EDGE_SPLIT", "Edge Split", ""},
{eModifierType_Explode, "EXPLODE", "Explode", ""},
{eModifierType_Fluidsim, "FLUID_SIMULATION", "Fluid Simulation", ""},
{eModifierType_Hook, "HOOK", "Hook", ""},
{eModifierType_Lattice, "LATTICE", "Lattice", ""},
{eModifierType_Mask, "MASK", "Mask", ""},
{eModifierType_MeshDeform, "MESH_DEFORM", "Mesh Deform", ""},
{eModifierType_Mirror, "MIRROR", "Mirror", ""},
{eModifierType_Multires, "MULTIRES", "Multires", ""},
{eModifierType_ParticleInstance, "PARTICLE_INSTANCE", "Particle Instance", ""},
{eModifierType_ParticleSystem, "PARTICLE_SYSTEM", "Particle System", ""},
{eModifierType_Shrinkwrap, "SHRINKWRAP", "Shrinkwrap", ""},
{eModifierType_SimpleDeform, "SIMPLE_DEFORM", "Simple Deform", ""},
{eModifierType_Smooth, "SMOOTH", "Smooth", ""},
{eModifierType_Softbody, "SOFTBODY", "Softbody", ""},
{eModifierType_Subsurf, "SUBSURF", "Subsurf", ""},
{eModifierType_UVProject, "UV_PROJECT", "UV Project", ""},
{eModifierType_Wave, "WAVE", "Wave", ""},
{0, NULL, NULL, NULL}};
{eModifierType_Armature, "ARMATURE", 0, "Armature", ""},
{eModifierType_Array, "ARRAY", 0, "Array", ""},
{eModifierType_Bevel, "BEVEL", 0, "Bevel", ""},
{eModifierType_Boolean, "BOOLEAN", 0, "Boolean", ""},
{eModifierType_Build, "BUILD", 0, "Build", ""},
{eModifierType_Cast, "CAST", 0, "Cast", ""},
{eModifierType_Cloth, "CLOTH", 0, "Cloth", ""},
{eModifierType_Collision, "COLLISION", 0, "Collision", ""},
{eModifierType_Curve, "CURVE", 0, "Curve", ""},
{eModifierType_Decimate, "DECIMATE", 0, "Decimate", ""},
{eModifierType_Displace, "DISPLACE", 0, "Displace", ""},
{eModifierType_EdgeSplit, "EDGE_SPLIT", 0, "Edge Split", ""},
{eModifierType_Explode, "EXPLODE", 0, "Explode", ""},
{eModifierType_Fluidsim, "FLUID_SIMULATION", 0, "Fluid Simulation", ""},
{eModifierType_Hook, "HOOK", 0, "Hook", ""},
{eModifierType_Lattice, "LATTICE", 0, "Lattice", ""},
{eModifierType_Mask, "MASK", 0, "Mask", ""},
{eModifierType_MeshDeform, "MESH_DEFORM", 0, "Mesh Deform", ""},
{eModifierType_Mirror, "MIRROR", 0, "Mirror", ""},
{eModifierType_Multires, "MULTIRES", 0, "Multires", ""},
{eModifierType_ParticleInstance, "PARTICLE_INSTANCE", 0, "Particle Instance", ""},
{eModifierType_ParticleSystem, "PARTICLE_SYSTEM", 0, "Particle System", ""},
{eModifierType_Shrinkwrap, "SHRINKWRAP", 0, "Shrinkwrap", ""},
{eModifierType_SimpleDeform, "SIMPLE_DEFORM", 0, "Simple Deform", ""},
{eModifierType_Smooth, "SMOOTH", 0, "Smooth", ""},
{eModifierType_Softbody, "SOFTBODY", 0, "Softbody", ""},
{eModifierType_Subsurf, "SUBSURF", 0, "Subsurf", ""},
{eModifierType_UVProject, "UV_PROJECT", 0, "UV Project", ""},
{eModifierType_Wave, "WAVE", 0, "Wave", ""},
{0, NULL, 0, NULL, NULL}};
#ifdef RNA_RUNTIME
@ -353,9 +353,9 @@ static void rna_ArrayModifier_curve_set(PointerRNA *ptr, PointerRNA value)
static void rna_def_property_subdivision_common(StructRNA *srna, const char type[])
{
static EnumPropertyItem prop_subdivision_type_items[] = {
{0, "CATMULL_CLARK", "Catmull-Clark", ""},
{1, "SIMPLE", "Simple", ""},
{0, NULL, NULL, NULL}};
{0, "CATMULL_CLARK", 0, "Catmull-Clark", ""},
{1, "SIMPLE", 0, "Simple", ""},
{0, NULL, 0, NULL, NULL}};
PropertyRNA *prop= RNA_def_property(srna, "subdivision_type", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, type);
@ -448,13 +448,13 @@ static void rna_def_modifier_curve(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_deform_axis_items[] = {
{MOD_CURVE_POSX, "POS_X", "X", ""},
{MOD_CURVE_POSY, "POS_Y", "Y", ""},
{MOD_CURVE_POSZ, "POS_Z", "Z", ""},
{MOD_CURVE_NEGX, "NEG_X", "-X", ""},
{MOD_CURVE_NEGY, "NEG_Y", "-Y", ""},
{MOD_CURVE_NEGZ, "NEG_Z", "-Z", ""},
{0, NULL, NULL, NULL}};
{MOD_CURVE_POSX, "POS_X", 0, "X", ""},
{MOD_CURVE_POSY, "POS_Y", 0, "Y", ""},
{MOD_CURVE_POSZ, "POS_Z", 0, "Z", ""},
{MOD_CURVE_NEGX, "NEG_X", 0, "-X", ""},
{MOD_CURVE_NEGY, "NEG_Y", 0, "-Y", ""},
{MOD_CURVE_NEGZ, "NEG_Z", 0, "-Z", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "CurveModifier", "Modifier");
RNA_def_struct_ui_text(srna, "Curve Modifier", "Curve deformation modifier.");
@ -597,11 +597,11 @@ static void rna_def_modifier_wave(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_texture_coordinates_items[] = {
{MOD_WAV_MAP_LOCAL, "LOCAL", "Local", ""},
{MOD_WAV_MAP_GLOBAL, "GLOBAL", "Global", ""},
{MOD_WAV_MAP_OBJECT, "OBJECT", "Object", ""},
{MOD_WAV_MAP_UV, "MAP_UV", "UV", ""},
{0, NULL, NULL, NULL}};
{MOD_WAV_MAP_LOCAL, "LOCAL", 0, "Local", ""},
{MOD_WAV_MAP_GLOBAL, "GLOBAL", 0, "Global", ""},
{MOD_WAV_MAP_OBJECT, "OBJECT", 0, "Object", ""},
{MOD_WAV_MAP_UV, "MAP_UV", 0, "UV", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "WaveModifier", "Modifier");
RNA_def_struct_ui_text(srna, "Wave Modifier", "Wave effect modifier.");
@ -844,10 +844,10 @@ static void rna_def_modifier_boolean(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_operation_items[] = {
{eBooleanModifierOp_Intersect, "INTERSECT", "Intersect", ""},
{eBooleanModifierOp_Union, "UNION", "Union", ""},
{eBooleanModifierOp_Difference, "DIFFERENCE", "Difference", ""},
{0, NULL, NULL, NULL}};
{eBooleanModifierOp_Intersect, "INTERSECT", 0, "Intersect", ""},
{eBooleanModifierOp_Union, "UNION", 0, "Union", ""},
{eBooleanModifierOp_Difference, "DIFFERENCE", 0, "Difference", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "BooleanModifier", "Modifier");
RNA_def_struct_ui_text(srna, "Boolean Modifier", "Boolean operations modifier.");
@ -872,10 +872,10 @@ static void rna_def_modifier_array(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_fit_type_items[] = {
{MOD_ARR_FIXEDCOUNT, "FIXED_COUNT", "Fixed Count", ""},
{MOD_ARR_FITLENGTH, "FIT_LENGTH", "Fit Length", ""},
{MOD_ARR_FITCURVE, "FIT_CURVE", "Fit Curve", ""},
{0, NULL, NULL, NULL}};
{MOD_ARR_FIXEDCOUNT, "FIXED_COUNT", 0, "Fixed Count", ""},
{MOD_ARR_FITLENGTH, "FIT_LENGTH", 0, "Fit Length", ""},
{MOD_ARR_FITCURVE, "FIT_CURVE", 0, "Fit Curve", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "ArrayModifier", "Modifier");
RNA_def_struct_ui_text(srna, "Array Modifier", "Array duplication modifier.");
@ -1005,19 +1005,19 @@ static void rna_def_modifier_displace(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_direction_items[] = {
{MOD_DISP_DIR_X, "X", "X", ""},
{MOD_DISP_DIR_Y, "Y", "Y", ""},
{MOD_DISP_DIR_Z, "Z", "Z", ""},
{MOD_DISP_DIR_NOR, "NORMAL", "Normal", ""},
{MOD_DISP_DIR_RGB_XYZ, "RGB_TO_XYZ", "RGB to XYZ", ""},
{0, NULL, NULL, NULL}};
{MOD_DISP_DIR_X, "X", 0, "X", ""},
{MOD_DISP_DIR_Y, "Y", 0, "Y", ""},
{MOD_DISP_DIR_Z, "Z", 0, "Z", ""},
{MOD_DISP_DIR_NOR, "NORMAL", 0, "Normal", ""},
{MOD_DISP_DIR_RGB_XYZ, "RGB_TO_XYZ", 0, "RGB to XYZ", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem prop_texture_coordinates_items[] = {
{MOD_DISP_MAP_LOCAL, "LOCAL", "Map", ""},
{MOD_DISP_MAP_GLOBAL, "GLOBAL", "Global", ""},
{MOD_DISP_MAP_OBJECT, "OBJECT", "Object", ""},
{MOD_DISP_MAP_UV, "UV", "UV", ""},
{0, NULL, NULL, NULL}};
{MOD_DISP_MAP_LOCAL, "LOCAL", 0, "Map", ""},
{MOD_DISP_MAP_GLOBAL, "GLOBAL", 0, "Global", ""},
{MOD_DISP_MAP_OBJECT, "OBJECT", 0, "Object", ""},
{MOD_DISP_MAP_UV, "UV", 0, "UV", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "DisplaceModifier", "Modifier");
RNA_def_struct_ui_text(srna, "Displace Modifier", "Displacement modifier.");
@ -1167,10 +1167,10 @@ static void rna_def_modifier_cast(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_cast_type_items[] = {
{MOD_CAST_TYPE_SPHERE, "SPHERE", "Sphere", ""},
{MOD_CAST_TYPE_CYLINDER, "CYLINDER", "Cylinder", ""},
{MOD_CAST_TYPE_CUBOID, "CUBOID", "Cuboid", ""},
{0, NULL, NULL, NULL}};
{MOD_CAST_TYPE_SPHERE, "SPHERE", 0, "Sphere", ""},
{MOD_CAST_TYPE_CYLINDER, "CYLINDER", 0, "Cylinder", ""},
{MOD_CAST_TYPE_CUBOID, "CUBOID", 0, "Cuboid", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "CastModifier", "Modifier");
RNA_def_struct_ui_text(srna, "Cast Modifier", "Cast modifier to cast to other shapes.");
@ -1412,16 +1412,16 @@ static void rna_def_modifier_bevel(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_limit_method_items[] = {
{0, "NONE", "None", "Bevel the entire mesh by a constant amount."},
{BME_BEVEL_ANGLE, "ANGLE", "Angle", "Only bevel edges with sharp enough angles between faces."},
{BME_BEVEL_WEIGHT, "WEIGHT", "Weight", "Use bevel weights to determine how much bevel is applied; apply them separately in vert/edge select mode."},
{0, NULL, NULL, NULL}};
{0, "NONE", 0, "None", "Bevel the entire mesh by a constant amount."},
{BME_BEVEL_ANGLE, "ANGLE", 0, "Angle", "Only bevel edges with sharp enough angles between faces."},
{BME_BEVEL_WEIGHT, "WEIGHT", 0, "Weight", "Use bevel weights to determine how much bevel is applied; apply them separately in vert/edge select mode."},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem prop_edge_weight_method_items[] = {
{0, "AVERAGE", "Average", ""},
{BME_BEVEL_EMIN, "SHARPEST", "Sharpest", ""},
{BME_BEVEL_EMAX, "LARGEST", "Largest", ""},
{0, NULL, NULL, NULL}};
{0, "AVERAGE", 0, "Average", ""},
{BME_BEVEL_EMIN, "SHARPEST", 0, "Sharpest", ""},
{BME_BEVEL_EMAX, "LARGEST", 0, "Largest", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "BevelModifier", "Modifier");
RNA_def_struct_ui_text(srna, "Bevel Modifier", "Bevel modifier to make edges and vertices more rounded.");
@ -1465,10 +1465,10 @@ static void rna_def_modifier_shrinkwrap(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_mode_items[] = {
{MOD_SHRINKWRAP_NEAREST_SURFACE, "NEAREST_SURFACEPOINT", "Nearest Surface Point", ""},
{MOD_SHRINKWRAP_PROJECT, "PROJECT", "Project", ""},
{MOD_SHRINKWRAP_NEAREST_VERTEX, "NEAREST_VERTEX", "Nearest Vertex", ""},
{0, NULL, NULL, NULL}};
{MOD_SHRINKWRAP_NEAREST_SURFACE, "NEAREST_SURFACEPOINT", 0, "Nearest Surface Point", ""},
{MOD_SHRINKWRAP_PROJECT, "PROJECT", 0, "Project", ""},
{MOD_SHRINKWRAP_NEAREST_VERTEX, "NEAREST_VERTEX", 0, "Nearest Vertex", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "ShrinkwrapModifier", "Modifier");
RNA_def_struct_ui_text(srna, "Shrinkwrap Modifier", "Shrink wrapping modifier to shrink wrap and object to a target.");
@ -1576,9 +1576,9 @@ static void rna_def_modifier_mask(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_mode_items[] = {
{MOD_MASK_MODE_VGROUP, "VERTEX_GROUP", "Vertex Group", ""},
{MOD_MASK_MODE_ARM, "ARMATURE", "Armature", ""},
{0, NULL, NULL, NULL}};
{MOD_MASK_MODE_VGROUP, "VERTEX_GROUP", 0, "Vertex Group", ""},
{MOD_MASK_MODE_ARM, "ARMATURE", 0, "Armature", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "MaskModifier", "Modifier");
RNA_def_struct_ui_text(srna, "Mask Modifier", "Mask modifier to hide parts of the mesh.");
@ -1615,11 +1615,11 @@ static void rna_def_modifier_simpledeform(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_mode_items[] = {
{MOD_SIMPLEDEFORM_MODE_TWIST, "TWIST", "Twist", ""},
{MOD_SIMPLEDEFORM_MODE_BEND, "BEND", "Bend", ""},
{MOD_SIMPLEDEFORM_MODE_TAPER, "TAPER", "Taper", ""},
{MOD_SIMPLEDEFORM_MODE_STRETCH, "STRETCH", "Stretch", ""},
{0, NULL, NULL, NULL}};
{MOD_SIMPLEDEFORM_MODE_TWIST, "TWIST", 0, "Twist", ""},
{MOD_SIMPLEDEFORM_MODE_BEND, "BEND", 0, "Bend", ""},
{MOD_SIMPLEDEFORM_MODE_TAPER, "TAPER", 0, "Taper", ""},
{MOD_SIMPLEDEFORM_MODE_STRETCH, "STRETCH", 0, "Stretch", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "SimpleDeformModifier", "Modifier");
RNA_def_struct_ui_text(srna, "SimpleDeform Modifier", "Simple deformation modifier to apply effects such as twisting and bending.");

254
source/blender/makesrna/intern/rna_nodetree.c
View File

@ -76,6 +76,7 @@ typedef struct NodeInfo
const char *enum_name;
const char *struct_name;
const char *base_name;
int icon;
const char *ui_name;
const char *ui_desc;
} NodeInfo;
@ -146,6 +147,7 @@ static EnumPropertyItem* alloc_node_type_items(int category)
if(node->defined && node->category == category) {
item->value = i;
item->identifier = node->enum_name;
item->icon = node->icon;
item->name = node->ui_name;
item->description = node->ui_desc;
@ -173,25 +175,25 @@ static void def_math(StructRNA *srna)
PropertyRNA *prop;
static EnumPropertyItem items[] = {
{ 0, "ADD", "Add", ""},
{ 1, "SUBTRACT", "Subtract", ""},
{ 2, "MULTIPLY", "Multiply", ""},
{ 3, "DIVIDE", "Divide", ""},
{ 4, "SINE", "Sine", ""},
{ 5, "COSINE", "Cosine", ""},
{ 6, "TANGENT", "Tangent", ""},
{ 7, "ARCSINE", "Arcsine", ""},
{ 8, "ARCCOSINE", "Arccosine", ""},
{ 9, "ARCTANGENT", "Arctangent", ""},
{10, "POWER", "Power", ""},
{11, "LOGARITHM", "Logarithm", ""},
{12, "MINIMUM", "Minimum", ""},
{13, "MAXIMUM", "Maximum", ""},
{14, "ROUND", "Round", ""},
{15, "LESS_THAN", "Less Than", ""},
{16, "GREATER_THAN", "Greater Than", ""},
{ 0, "ADD", 0, "Add", ""},
{ 1, "SUBTRACT", 0, "Subtract", ""},
{ 2, "MULTIPLY", 0, "Multiply", ""},
{ 3, "DIVIDE", 0, "Divide", ""},
{ 4, "SINE", 0, "Sine", ""},
{ 5, "COSINE", 0, "Cosine", ""},
{ 6, "TANGENT", 0, "Tangent", ""},
{ 7, "ARCSINE", 0, "Arcsine", ""},
{ 8, "ARCCOSINE", 0, "Arccosine", ""},
{ 9, "ARCTANGENT", 0, "Arctangent", ""},
{10, "POWER", 0, "Power", ""},
{11, "LOGARITHM", 0, "Logarithm", ""},
{12, "MINIMUM", 0, "Minimum", ""},
{13, "MAXIMUM", 0, "Maximum", ""},
{14, "ROUND", 0, "Round", ""},
{15, "LESS_THAN", 0, "Less Than", ""},
{16, "GREATER_THAN", 0, "Greater Than", ""},
{0, NULL, NULL, NULL}
{0, NULL, 0, NULL, NULL}
};
prop = RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE);
@ -205,14 +207,14 @@ static void def_vector_math(StructRNA *srna)
PropertyRNA *prop;
static EnumPropertyItem items[] = {
{0, "ADD", "Add", ""},
{1, "SUBTRACT", "Subtract", ""},
{2, "AVERAGE", "Average", ""},
{3, "DOT_PRODUCT", "Dot Product", ""},
{4, "CROSS_PRODUCT", "Cross Product", ""},
{5, "NORMALIZE", "Normalize", ""},
{0, "ADD", 0, "Add", ""},
{1, "SUBTRACT", 0, "Subtract", ""},
{2, "AVERAGE", 0, "Average", ""},
{3, "DOT_PRODUCT", 0, "Dot Product", ""},
{4, "CROSS_PRODUCT", 0, "Cross Product", ""},
{5, "NORMALIZE", 0, "Normalize", ""},
{0, NULL, NULL, NULL}
{0, NULL, 0, NULL, NULL}
};
prop = RNA_def_property(srna, "operation", PROP_ENUM, PROP_NONE);
@ -275,23 +277,23 @@ static void def_mix_rgb(StructRNA *srna)
PropertyRNA *prop;
static EnumPropertyItem blend_type_items[] = {
{ 0, "MIX", "Mix", ""},
{ 1, "ADD", "Add", ""},
{ 3, "SUBTRACT", "Subtract", ""},
{ 2, "MULTIPLY", "Multiply", ""},
{ 4, "SCREEN", "Screen", ""},
{ 9, "OVERLAY", "Overlay", ""},
{ 5, "DIVIDE", "Divide", ""},
{ 6, "DIFFERENCE", "Difference", ""},
{ 7, "DARKEN", "Darken", ""},
{ 8, "LIGHTEN", "Lighten", ""},
{10, "DODGE", "Dodge", ""},
{11, "BURN", "Burn", ""},
{15, "COLOR", "Color", ""},
{14, "VALUE", "Value", ""},
{13, "SATURATION", "Saturation", ""},
{12, "HUE", "Hue", ""},
{0, NULL, NULL, NULL}
{ 0, "MIX", 0, "Mix", ""},
{ 1, "ADD", 0, "Add", ""},
{ 3, "SUBTRACT", 0, "Subtract", ""},
{ 2, "MULTIPLY", 0, "Multiply", ""},
{ 4, "SCREEN", 0, "Screen", ""},
{ 9, "OVERLAY", 0, "Overlay", ""},
{ 5, "DIVIDE", 0, "Divide", ""},
{ 6, "DIFFERENCE", 0, "Difference", ""},
{ 7, "DARKEN", 0, "Darken", ""},
{ 8, "LIGHTEN", 0, "Lighten", ""},
{10, "DODGE", 0, "Dodge", ""},
{11, "BURN", 0, "Burn", ""},
{15, "COLOR", 0, "Color", ""},
{14, "VALUE", 0, "Value", ""},
{13, "SATURATION", 0, "Saturation", ""},
{12, "HUE", 0, "Hue", ""},
{0, NULL, 0, NULL, NULL}
};
prop = RNA_def_property(srna, "blend_type", PROP_ENUM, PROP_NONE);
@ -393,15 +395,15 @@ static void def_cmp_blur(StructRNA *srna)
PropertyRNA *prop;
static EnumPropertyItem filter_type_items[] = {
{R_FILTER_BOX, "FLAT", "Flat", ""},
{R_FILTER_TENT, "TENT", "Tent", ""},
{R_FILTER_QUAD, "QUAD", "Quadratic", ""},
{R_FILTER_CUBIC, "CUBIC", "Cubic", ""},
{R_FILTER_GAUSS, "GAUSS", "Gaussian", ""},
{R_FILTER_FAST_GAUSS, "FAST_GAUSS", "Fast Gaussian", ""},
{R_FILTER_CATROM, "CATROM", "Catrom", ""},
{R_FILTER_MITCH, "MITCH", "Mitch", ""},
{0, NULL, NULL, NULL}
{R_FILTER_BOX, "FLAT", 0, "Flat", ""},
{R_FILTER_TENT, "TENT", 0, "Tent", ""},
{R_FILTER_QUAD, "QUAD", 0, "Quadratic", ""},
{R_FILTER_CUBIC, "CUBIC", 0, "Cubic", ""},
{R_FILTER_GAUSS, "GAUSS", 0, "Gaussian", ""},
{R_FILTER_FAST_GAUSS, "FAST_GAUSS", 0, "Fast Gaussian", ""},
{R_FILTER_CATROM, "CATROM", 0, "Catrom", ""},
{R_FILTER_MITCH, "MITCH", 0, "Mitch", ""},
{0, NULL, 0, NULL, NULL}
};
RNA_def_struct_sdna_from(srna, "NodeBlurData", "storage");
@ -471,14 +473,14 @@ static void def_cmp_filter(StructRNA *srna)
PropertyRNA *prop;
static EnumPropertyItem type_items[] = {
{0, "SOFTEN", "Soften", ""},
{1, "SHARPEN", "Sharpen", ""},
{2, "LAPLACE", "Laplace", ""},
{3, "SOBEL", "Sobel", ""},
{4, "PREWITT", "Prewitt", ""},
{5, "KIRSCH", "Kirsch", ""},
{6, "SHADOW", "Shadow", ""},
{0, NULL, NULL, NULL}
{0, "SOFTEN", 0, "Soften", ""},
{1, "SHARPEN", 0, "Sharpen", ""},
{2, "LAPLACE", 0, "Laplace", ""},
{3, "SOBEL", 0, "Sobel", ""},
{4, "PREWITT", 0, "Prewitt", ""},
{5, "KIRSCH", 0, "Kirsch", ""},
{6, "SHADOW", 0, "Shadow", ""},
{0, NULL, 0, NULL, NULL}
};
prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
@ -550,11 +552,11 @@ static void def_cmp_image(StructRNA *srna)
PropertyRNA *prop;
/*static EnumPropertyItem type_items[] = {
{IMA_SRC_FILE, "IMAGE", "Image", ""},
{IMA_SRC_FILE, "IMAGE", 0, "Image", ""},
{IMA_SRC_MOVIE, "MOVIE", "Movie", ""},
{IMA_SRC_SEQUENCE, "SEQUENCE", "Sequence", ""},
{IMA_SRC_GENERATED, "GENERATED", "Generated", ""},
{0, NULL, NULL, NULL}
{0, NULL, 0, NULL, NULL}
};*/
prop = RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
@ -627,26 +629,26 @@ static void def_cmp_output_file(StructRNA *srna)
PropertyRNA *prop;
static EnumPropertyItem type_items[] = {
{R_TARGA, "TARGA", "Targa", ""},
{R_RAWTGA, "RAW_TARGA", "Targa Raw", ""},
{R_PNG, "PNG", "PNG", ""},
{R_BMP, "BMP", "BMP", ""},
{R_JPEG90, "JPEG", "JPEG", ""},
{R_IRIS, "IRIS", "IRIS", ""},
{R_RADHDR, "RADIANCE_HDR", "Radiance HDR", ""},
{R_CINEON, "CINEON", "Cineon", ""},
{R_DPX, "DPX", "DPX", ""},
{R_OPENEXR, "OPENEXR", "OpenEXR", ""},
{0, NULL, NULL, NULL}
{R_TARGA, "TARGA", 0, "Targa", ""},
{R_RAWTGA, "RAW_TARGA", 0, "Targa Raw", ""},
{R_PNG, "PNG", 0, "PNG", ""},
{R_BMP, "BMP", 0, "BMP", ""},
{R_JPEG90, "JPEG", 0, "JPEG", ""},
{R_IRIS, "IRIS", 0, "IRIS", ""},
{R_RADHDR, "RADIANCE_HDR", 0, "Radiance HDR", ""},
{R_CINEON, "CINEON", 0, "Cineon", ""},
{R_DPX, "DPX", 0, "DPX", ""},
{R_OPENEXR, "OPENEXR", 0, "OpenEXR", ""},
{0, NULL, 0, NULL, NULL}
};
static EnumPropertyItem openexr_codec_items[] = {
{0, "NONE", "None", ""},
{1, "PXR24", "Pxr24 (lossy)", ""},
{2, "ZIP", "ZIP (lossless)", ""},
{3, "PIZ", "PIX (lossless)", ""},
{4, "RLE", "RLE (lossless)", ""},
{0, NULL, NULL, NULL}
{0, "NONE", 0, "None", ""},
{1, "PXR24", 0, "Pxr24 (lossy)", ""},
{2, "ZIP", 0, "ZIP (lossless)", ""},
{3, "PIZ", 0, "PIX (lossless)", ""},
{4, "RLE", 0, "RLE (lossless)", ""},
{0, NULL, 0, NULL, NULL}
};
RNA_def_struct_sdna_from(srna, "NodeImageFile", "storage");
@ -702,10 +704,10 @@ static void def_cmp_scale(StructRNA *srna)
PropertyRNA *prop;
static EnumPropertyItem space_items[] = {
{0, "RELATIVE", "Relative", ""},
{1, "ABSOLUTE", "Absolute", ""},
{2, "SCENE_SIZE", "Scene Size", ""},
{0, NULL, NULL, NULL}
{0, "RELATIVE", 0, "Relative", ""},
{1, "ABSOLUTE", 0, "Absolute", ""},
{2, "SCENE_SIZE", 0, "Scene Size", ""},
{0, NULL, 0, NULL, NULL}
};
prop = RNA_def_property(srna, "space", PROP_ENUM, PROP_NONE);
@ -719,11 +721,11 @@ static void def_cmp_diff_matte(StructRNA *srna)
PropertyRNA *prop;
static EnumPropertyItem color_space_items[] = {
{1, "RGB", "RGB", ""},
{2, "HSV", "HSV", ""},
{3, "YUV", "YUV", ""},
{4, "YCC", "YCbCr", ""},
{0, NULL, NULL, NULL}
{1, "RGB", 0, "RGB", ""},
{2, "HSV", 0, "HSV", ""},
{3, "YUV", 0, "YUV", ""},
{4, "YCC", 0, "YCbCr", ""},
{0, NULL, 0, NULL, NULL}
};
prop = RNA_def_property(srna, "color_space", PROP_ENUM, PROP_NONE);
@ -757,10 +759,10 @@ static void def_cmp_color_spill(StructRNA *srna)
PropertyRNA *prop;
static EnumPropertyItem channel_items[] = {
{1, "R", "Red", ""},
{2, "G", "Green", ""},
{3, "B", "Blue", ""},
{0, NULL, NULL, NULL}
{1, "R", 0, "Red", ""},
{2, "G", 0, "Green", ""},
{3, "B", 0, "Blue", ""},
{0, NULL, 0, NULL, NULL}
};
prop = RNA_def_property(srna, "channel", PROP_ENUM, PROP_NONE);
@ -812,11 +814,11 @@ static void def_cmp_channel_matte(StructRNA *srna)
PropertyRNA *prop;
static EnumPropertyItem color_space_items[] = {
{1, "RGB", "RGB", ""},
{2, "HSV", "HSV", ""},
{3, "YUV", "YUV", ""},
{4, "YCC", "YCbCr", ""},
{0, NULL, NULL, NULL}
{1, "RGB", 0, "RGB", ""},
{2, "HSV", 0, "HSV", ""},
{3, "YUV", 0, "YUV", ""},
{4, "YCC", 0, "YCbCr", ""},
{0, NULL, 0, NULL, NULL}
};
prop = RNA_def_property(srna, "color_space", PROP_ENUM, PROP_NONE);
@ -850,10 +852,10 @@ static void def_cmp_flip(StructRNA *srna)
PropertyRNA *prop;
static EnumPropertyItem axis_items[] = {
{0, "X", "X", ""},
{1, "Y", "Y", ""},
{2, "XY", "X & Y", ""},
{0, NULL, NULL, NULL}
{0, "X", 0, "X", ""},
{1, "Y", 0, "Y", ""},
{2, "XY", 0, "X & Y", ""},
{0, NULL, 0, NULL, NULL}
};
prop = RNA_def_property(srna, "axis", PROP_ENUM, PROP_NONE);
@ -867,9 +869,9 @@ static void def_cmp_splitviewer(StructRNA *srna)
PropertyRNA *prop;
static EnumPropertyItem axis_items[] = {
{0, "X", "X", ""},
{1, "Y", "Y", ""},
{0, NULL, NULL, NULL}
{0, "X", 0, "X", ""},
{1, "Y", 0, "Y", ""},
{0, NULL, 0, NULL, NULL}
};
prop = RNA_def_property(srna, "axis", PROP_ENUM, PROP_NONE);
@ -907,14 +909,14 @@ static void def_cmp_defocus(StructRNA *srna)
PropertyRNA *prop;
static EnumPropertyItem bokeh_items[] = {
{8, "OCTAGON", "Octagonal", "8 sides"},
{7, "HEPTAGON", "Heptagonal", "7 sides"},
{6, "HEXAGON", "Hexagonal", "6 sides"},
{5, "PENTAGON", "Pentagonal", "5 sides"},
{4, "SQUARE", "Square", "4 sides"},
{3, "TRIANGLE", "Triangular", "3 sides"},
{0, "CIRCLE", "Circular", ""},
{0, NULL, NULL, NULL}
{8, "OCTAGON", 0, "Octagonal", "8 sides"},
{7, "HEPTAGON", 0, "Heptagonal", "7 sides"},
{6, "HEXAGON", 0, "Hexagonal", "6 sides"},
{5, "PENTAGON", 0, "Pentagonal", "5 sides"},
{4, "SQUARE", 0, "Square", "4 sides"},
{3, "TRIANGLE", 0, "Triangular", "3 sides"},
{0, "CIRCLE", 0, "Circular", ""},
{0, NULL, 0, NULL, NULL}
};
RNA_def_struct_sdna_from(srna, "NodeDefocus", "storage");
@ -1085,9 +1087,9 @@ static void def_cmp_premul_key(StructRNA *srna)
PropertyRNA *prop;
static EnumPropertyItem type_items[] = {
{0, "KEY_TO_PREMUL", "Key to Premul", ""},
{1, "PREMUL_TO_KEY", "Premul to Key", ""},
{0, NULL, NULL, NULL}
{0, "KEY_TO_PREMUL", 0, "Key to Premul", ""},
{1, "PREMUL_TO_KEY", 0, "Premul to Key", ""},
{0, NULL, 0, NULL, NULL}
};
prop = RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
@ -1102,18 +1104,18 @@ static void def_cmp_glare(StructRNA *srna)
PropertyRNA *prop;
static EnumPropertyItem type_items[] = {
{3, "GHOSTS", "Ghosts", ""},
{2, "STREAKS", "Streaks", ""},
{1, "FOG_GLOW", "Fog Glow", ""},
{0, "SIMPLE_STAR", "Simple Star", ""},
{0, NULL, NULL, NULL}
{3, "GHOSTS", 0, "Ghosts", ""},
{2, "STREAKS", 0, "Streaks", ""},
{1, "FOG_GLOW", 0, "Fog Glow", ""},
{0, "SIMPLE_STAR", 0, "Simple Star", ""},
{0, NULL, 0, NULL, NULL}
};
/*static EnumPropertyItem quality_items[] = {
{0, "HIGH", "High", ""},
{1, "MEDIUM", "Medium", ""},
{2, "LOW", "Low", ""},
{0, NULL, NULL, NULL}
{0, "HIGH", 0, "High", ""},
{1, "MEDIUM", 0, "Medium", ""},
{2, "LOW", 0, "Low", ""},
{0, NULL, 0, NULL, NULL}
};*/
RNA_def_struct_sdna_from(srna, "NodeGlare", "storage");
@ -1172,9 +1174,9 @@ static void def_cmp_tonemap(StructRNA *srna)
PropertyRNA *prop;
static EnumPropertyItem type_items[] = {
{1, "RD_PHOTORECEPTOR", "R/D Photoreceptor", ""},
{0, "RH_SIMPLE", "Rh Simple", ""},
{0, NULL, NULL, NULL}
{1, "RD_PHOTORECEPTOR", 0, "R/D Photoreceptor", ""},
{0, "RH_SIMPLE", 0, "Rh Simple", ""},
{0, NULL, 0, NULL, NULL}
};
RNA_def_struct_sdna_from(srna, "NodeTonemap", "storage");

150
source/blender/makesrna/intern/rna_object.c
View File

@ -392,9 +392,9 @@ static void rna_def_material_slot(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem link_items[] = {
{0, "DATA", "Data", ""},
{1, "OBJECT", "Object", ""},
{0, NULL, NULL, NULL}};
{0, "DATA", 0, "Data", ""},
{1, "OBJECT", 0, "Object", ""},
{0, NULL, 0, NULL, NULL}};
/* NOTE: there is no MaterialSlot equivalent in DNA, so the internal
* pointer data points to ob->mat + index, and we manually implement
@ -428,22 +428,22 @@ static void rna_def_object_game_settings(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem body_type_items[] = {
{OB_BODY_TYPE_NO_COLLISION, "NO_COLLISION", "No Collision", ""},
{OB_BODY_TYPE_STATIC, "STATIC", "Static", ""},
{OB_BODY_TYPE_DYNAMIC, "DYNAMIC", "Dynamic", ""},
{OB_BODY_TYPE_RIGID, "RIGID_BODY", "Rigid Body", ""},
{OB_BODY_TYPE_SOFT, "SOFT_BODY", "Soft Body", ""},
{0, NULL, NULL, NULL}};
{OB_BODY_TYPE_NO_COLLISION, "NO_COLLISION", 0, "No Collision", ""},
{OB_BODY_TYPE_STATIC, "STATIC", 0, "Static", ""},
{OB_BODY_TYPE_DYNAMIC, "DYNAMIC", 0, "Dynamic", ""},
{OB_BODY_TYPE_RIGID, "RIGID_BODY", 0, "Rigid Body", ""},
{OB_BODY_TYPE_SOFT, "SOFT_BODY", 0, "Soft Body", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem collision_bounds_items[] = {
{OB_BOUND_BOX, "BOX", "Box", ""},
{OB_BOUND_SPHERE, "SPHERE", "Sphere", ""},
{OB_BOUND_CYLINDER, "CYLINDER", "Cylinder", ""},
{OB_BOUND_CONE, "CONE", "Cone", ""},
{OB_BOUND_POLYH, "CONVEX_HULL", "Convex Hull", ""},
{OB_BOUND_POLYT, "TRIANGLE_MESH", "Triangle Mesh", ""},
//{OB_DYN_MESH, "DYNAMIC_MESH", "Dynamic Mesh", ""},
{0, NULL, NULL, NULL}};
{OB_BOUND_BOX, "BOX", 0, "Box", ""},
{OB_BOUND_SPHERE, "SPHERE", 0, "Sphere", ""},
{OB_BOUND_CYLINDER, "CYLINDER", 0, "Cylinder", ""},
{OB_BOUND_CONE, "CONE", 0, "Cone", ""},
{OB_BOUND_POLYH, "CONVEX_HULL", 0, "Convex Hull", ""},
{OB_BOUND_POLYT, "TRIANGLE_MESH", 0, "Triangle Mesh", ""},
//{OB_DYN_MESH, "DYNAMIC_MESH", 0, "Dynamic Mesh", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "GameObjectSettings", NULL);
RNA_def_struct_sdna(srna, "Object");
@ -590,78 +590,78 @@ static StructRNA *rna_def_object(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem parent_type_items[] = {
{PAROBJECT, "OBJECT", "Object", ""},
{PARCURVE, "CURVE", "Curve", ""},
//{PARKEY, "KEY", "Key", ""},
{PARSKEL, "ARMATURE", "Armature", ""},
{PARSKEL, "LATTICE", "Lattice", ""}, // PARSKEL reuse will give issues
{PARVERT1, "VERTEX", "Vertex", ""},
{PARVERT3, "VERTEX_3", "3 Vertices", ""},
{PARBONE, "BONE", "Bone", ""},
{0, NULL, NULL, NULL}};
{PAROBJECT, "OBJECT", 0, "Object", ""},
{PARCURVE, "CURVE", 0, "Curve", ""},
//{PARKEY, "KEY", 0, "Key", ""},
{PARSKEL, "ARMATURE", 0, "Armature", ""},
{PARSKEL, "LATTICE", 0, "Lattice", ""}, // PARSKEL reuse will give issues
{PARVERT1, "VERTEX", 0, "Vertex", ""},
{PARVERT3, "VERTEX_3", 0, "3 Vertices", ""},
{PARBONE, "BONE", 0, "Bone", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem object_type_items[] = {
{OB_EMPTY, "EMPTY", "Empty", ""},
{OB_MESH, "MESH", "Mesh", ""},
{OB_CURVE, "CURVE", "Curve", ""},
{OB_SURF, "SURFACE", "Surface", ""},
{OB_FONT, "TEXT", "Text", ""},
{OB_MBALL, "META", "Meta", ""},
{OB_LAMP, "LAMP", "Lamp", ""},
{OB_CAMERA, "CAMERA", "Camera", ""},
{OB_WAVE, "WAVE", "Wave", ""},
{OB_LATTICE, "LATTICE", "Lattice", ""},
{OB_ARMATURE, "ARMATURE", "Armature", ""},
{0, NULL, NULL, NULL}};
{OB_EMPTY, "EMPTY", 0, "Empty", ""},
{OB_MESH, "MESH", 0, "Mesh", ""},
{OB_CURVE, "CURVE", 0, "Curve", ""},
{OB_SURF, "SURFACE", 0, "Surface", ""},
{OB_FONT, "TEXT", 0, "Text", ""},
{OB_MBALL, "META", 0, "Meta", ""},
{OB_LAMP, "LAMP", 0, "Lamp", ""},
{OB_CAMERA, "CAMERA", 0, "Camera", ""},
{OB_WAVE, "WAVE", 0, "Wave", ""},
{OB_LATTICE, "LATTICE", 0, "Lattice", ""},
{OB_ARMATURE, "ARMATURE", 0, "Armature", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem empty_drawtype_items[] = {
{OB_ARROWS, "ARROWS", "Arrows", ""},
{OB_SINGLE_ARROW, "SINGLE_ARROW", "Single Arrow", ""},
{OB_PLAINAXES, "PLAIN_AXES", "Plain Axes", ""},
{OB_CIRCLE, "CIRCLE", "Circle", ""},
{OB_CUBE, "CUBE", "Cube", ""},
{OB_EMPTY_SPHERE, "SPHERE", "Sphere", ""},
{OB_EMPTY_CONE, "CONE", "Cone", ""},
{0, NULL, NULL, NULL}};
{OB_ARROWS, "ARROWS", 0, "Arrows", ""},
{OB_SINGLE_ARROW, "SINGLE_ARROW", 0, "Single Arrow", ""},
{OB_PLAINAXES, "PLAIN_AXES", 0, "Plain Axes", ""},
{OB_CIRCLE, "CIRCLE", 0, "Circle", ""},
{OB_CUBE, "CUBE", 0, "Cube", ""},
{OB_EMPTY_SPHERE, "SPHERE", 0, "Sphere", ""},
{OB_EMPTY_CONE, "CONE", 0, "Cone", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem track_items[] = {
{OB_POSX, "POSX", "+X", ""},
{OB_POSY, "POSY", "+Y", ""},
{OB_POSZ, "POSZ", "+Z", ""},
{OB_NEGX, "NEGX", "-X", ""},
{OB_NEGY, "NEGY", "-Y", ""},
{OB_NEGZ, "NEGZ", "-Z", ""},
{0, NULL, NULL, NULL}};
{OB_POSX, "POSX", 0, "+X", ""},
{OB_POSY, "POSY", 0, "+Y", ""},
{OB_POSZ, "POSZ", 0, "+Z", ""},
{OB_NEGX, "NEGX", 0, "-X", ""},
{OB_NEGY, "NEGY", 0, "-Y", ""},
{OB_NEGZ, "NEGZ", 0, "-Z", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem up_items[] = {
{OB_POSX, "X", "X", ""},
{OB_POSY, "Y", "Y", ""},
{OB_POSZ, "Z", "Z", ""},
{0, NULL, NULL, NULL}};
{OB_POSX, "X", 0, "X", ""},
{OB_POSY, "Y", 0, "Y", ""},
{OB_POSZ, "Z", 0, "Z", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem drawtype_items[] = {
{OB_BOUNDBOX, "BOUNDS", "Bounds", ""},
{OB_WIRE, "WIRE", "Wire", ""},
{OB_SOLID, "SOLID", "Solid", ""},
{OB_SHADED, "SHADED", "Shaded", ""},
{OB_TEXTURE, "TEXTURED", "Textured", ""},
{0, NULL, NULL, NULL}};
{OB_BOUNDBOX, "BOUNDS", 0, "Bounds", ""},
{OB_WIRE, "WIRE", 0, "Wire", ""},
{OB_SOLID, "SOLID", 0, "Solid", ""},
{OB_SHADED, "SHADED", 0, "Shaded", ""},
{OB_TEXTURE, "TEXTURED", 0, "Textured", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem boundtype_items[] = {
{OB_BOUND_BOX, "BOX", "Box", ""},
{OB_BOUND_SPHERE, "SPHERE", "Sphere", ""},
{OB_BOUND_CYLINDER, "CYLINDER", "Cylinder", ""},
{OB_BOUND_CONE, "CONE", "Cone", ""},
{OB_BOUND_POLYH, "POLYHEDER", "Polyheder", ""},
{0, NULL, NULL, NULL}};
{OB_BOUND_BOX, "BOX", 0, "Box", ""},
{OB_BOUND_SPHERE, "SPHERE", 0, "Sphere", ""},
{OB_BOUND_CYLINDER, "CYLINDER", 0, "Cylinder", ""},
{OB_BOUND_CONE, "CONE", 0, "Cone", ""},
{OB_BOUND_POLYH, "POLYHEDER", 0, "Polyheder", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem dupli_items[] = {
{0, "NONE", "None", ""},
{OB_DUPLIFRAMES, "FRAMES", "Frames", "Make copy of object for every frame."},
{OB_DUPLIVERTS, "VERTS", "Verts", "Duplicate child objects on all vertices."},
{OB_DUPLIFACES, "FACES", "Faces", "Duplicate child objects on all faces."},
{OB_DUPLIGROUP, "GROUP", "Group", "Enable group instancing."},
{0, NULL, NULL, NULL}};
{0, "NONE", 0, "None", ""},
{OB_DUPLIFRAMES, "FRAMES", 0, "Frames", "Make copy of object for every frame."},
{OB_DUPLIVERTS, "VERTS", 0, "Verts", "Duplicate child objects on all vertices."},
{OB_DUPLIFACES, "FACES", 0, "Faces", "Duplicate child objects on all faces."},
{OB_DUPLIGROUP, "GROUP", 0, "Group", "Enable group instancing."},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "Object", "ID");
RNA_def_struct_ui_text(srna, "Object", "Object datablock defining an object in a scene..");

38
source/blender/makesrna/intern/rna_object_force.c
View File

@ -136,29 +136,29 @@ static void rna_def_field(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem field_type_items[] = {
{0, "NONE", "None", ""},
{PFIELD_FORCE, "SPHERICAL", "Spherical", ""},
{PFIELD_VORTEX, "VORTEX", "Vortex", ""},
{PFIELD_MAGNET, "MAGNET", "Magnetic", ""},
{PFIELD_WIND, "WIND", "Wind", ""},
{PFIELD_GUIDE, "GUIDE", "Curve Guide", ""},
{PFIELD_TEXTURE, "TEXTURE", "Texture", ""},
{PFIELD_HARMONIC, "HARMONIC", "Harmonic", ""},
{PFIELD_CHARGE, "CHARGE", "Charge", ""},
{PFIELD_LENNARDJ, "LENNARDJ", "Lennard-Jones", ""},
{0, NULL, NULL, NULL}};
{0, "NONE", 0, "None", ""},
{PFIELD_FORCE, "SPHERICAL", 0, "Spherical", ""},
{PFIELD_VORTEX, "VORTEX", 0, "Vortex", ""},
{PFIELD_MAGNET, "MAGNET", 0, "Magnetic", ""},
{PFIELD_WIND, "WIND", 0, "Wind", ""},
{PFIELD_GUIDE, "GUIDE", 0, "Curve Guide", ""},
{PFIELD_TEXTURE, "TEXTURE", 0, "Texture", ""},
{PFIELD_HARMONIC, "HARMONIC", 0, "Harmonic", ""},
{PFIELD_CHARGE, "CHARGE", 0, "Charge", ""},
{PFIELD_LENNARDJ, "LENNARDJ", 0, "Lennard-Jones", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem falloff_items[] = {
{PFIELD_FALL_SPHERE, "SPHERE", "Sphere", ""},
{PFIELD_FALL_TUBE, "TUBE", "Tube", ""},
{PFIELD_FALL_CONE, "CONE", "Cone", ""},
{0, NULL, NULL, NULL}};
{PFIELD_FALL_SPHERE, "SPHERE", 0, "Sphere", ""},
{PFIELD_FALL_TUBE, "TUBE", 0, "Tube", ""},
{PFIELD_FALL_CONE, "CONE", 0, "Cone", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem texture_items[] = {
{PFIELD_TEX_RGB, "RGB", "RGB", ""},
{PFIELD_TEX_GRAD, "GRADIENT", "Gradient", ""},
{PFIELD_TEX_CURL, "CURL", "Curl", ""},
{0, NULL, NULL, NULL}};
{PFIELD_TEX_RGB, "RGB", 0, "RGB", ""},
{PFIELD_TEX_GRAD, "GRADIENT", 0, "Gradient", ""},
{PFIELD_TEX_CURL, "CURL", 0, "Curl", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "FieldSettings", NULL);
RNA_def_struct_sdna(srna, "PartDeflect");

216
source/blender/makesrna/intern/rna_particle.c
View File

@ -160,18 +160,18 @@ static void rna_ParticleSystem_name_get(PointerRNA *ptr, char *str)
}
static EnumPropertyItem from_items[] = {
{PART_FROM_VERT, "VERT", "Vertexes", ""},
{PART_FROM_FACE, "FACE", "Faces", ""},
{PART_FROM_VOLUME, "VOLUME", "Volume", ""},
{0, NULL, NULL, NULL}
{PART_FROM_VERT, "VERT", 0, "Vertexes", ""},
{PART_FROM_FACE, "FACE", 0, "Faces", ""},
{PART_FROM_VOLUME, "VOLUME", 0, "Volume", ""},
{0, NULL, 0, NULL, NULL}
};
static EnumPropertyItem reactor_from_items[] = {
{PART_FROM_VERT, "VERT", "Vertexes", ""},
{PART_FROM_FACE, "FACE", "Faces", ""},
{PART_FROM_VOLUME, "VOLUME", "Volume", ""},
{PART_FROM_PARTICLE, "PARTICLE", "Particle", ""},
{0, NULL, NULL, NULL}
{PART_FROM_VERT, "VERT", 0, "Vertexes", ""},
{PART_FROM_FACE, "FACE", 0, "Faces", ""},
{PART_FROM_VOLUME, "VOLUME", 0, "Volume", ""},
{PART_FROM_PARTICLE, "PARTICLE", 0, "Particle", ""},
{0, NULL, 0, NULL, NULL}
};
static EnumPropertyItem *rna_Particle_from_itemf(PointerRNA *ptr)
@ -185,39 +185,39 @@ static EnumPropertyItem *rna_Particle_from_itemf(PointerRNA *ptr)
}
static EnumPropertyItem draw_as_items[] = {
{PART_DRAW_NOT, "NONE", "None", ""},
{PART_DRAW_REND, "RENDER", "Rendered", ""},
{PART_DRAW_DOT, "DOT", "Point", ""},
{PART_DRAW_CIRC, "CIRC", "Circle", ""},
{PART_DRAW_CROSS, "CROSS", "Cross", ""},
{PART_DRAW_AXIS, "AXIS", "Axis", ""},
{0, NULL, NULL, NULL}
{PART_DRAW_NOT, "NONE", 0, "None", ""},
{PART_DRAW_REND, "RENDER", 0, "Rendered", ""},
{PART_DRAW_DOT, "DOT", 0, "Point", ""},
{PART_DRAW_CIRC, "CIRC", 0, "Circle", ""},
{PART_DRAW_CROSS, "CROSS", 0, "Cross", ""},
{PART_DRAW_AXIS, "AXIS", 0, "Axis", ""},
{0, NULL, 0, NULL, NULL}
};
static EnumPropertyItem hair_draw_as_items[] = {
{PART_DRAW_NOT, "NONE", "None", ""},
{PART_DRAW_REND, "RENDER", "Rendered", ""},
{PART_DRAW_PATH, "PATH", "Path", ""},
{0, NULL, NULL, NULL}
{PART_DRAW_NOT, "NONE", 0, "None", ""},
{PART_DRAW_REND, "RENDER", 0, "Rendered", ""},
{PART_DRAW_PATH, "PATH", 0, "Path", ""},
{0, NULL, 0, NULL, NULL}
};
static EnumPropertyItem ren_as_items[] = {
{PART_DRAW_NOT, "NONE", "None", ""},
{PART_DRAW_HALO, "HALO", "Halo", ""},
{PART_DRAW_LINE, "LINE", "Line", ""},
{PART_DRAW_PATH, "PATH", "Path", ""},
{PART_DRAW_OB, "OBJECT", "Object", ""},
{PART_DRAW_GR, "GROUP", "Group", ""},
{PART_DRAW_BB, "BILLBOARD", "Billboard", ""},
{0, NULL, NULL, NULL}
{PART_DRAW_NOT, "NONE", 0, "None", ""},
{PART_DRAW_HALO, "HALO", 0, "Halo", ""},
{PART_DRAW_LINE, "LINE", 0, "Line", ""},
{PART_DRAW_PATH, "PATH", 0, "Path", ""},
{PART_DRAW_OB, "OBJECT", 0, "Object", ""},
{PART_DRAW_GR, "GROUP", 0, "Group", ""},
{PART_DRAW_BB, "BILLBOARD", 0, "Billboard", ""},
{0, NULL, 0, NULL, NULL}
};
static EnumPropertyItem hair_ren_as_items[] = {
{PART_DRAW_NOT, "NONE", "None", ""},
{PART_DRAW_PATH, "PATH", "Path", ""},
{PART_DRAW_OB, "OBJECT", "Object", ""},
{PART_DRAW_GR, "GROUP", "Group", ""},
{0, NULL, NULL, NULL}
{PART_DRAW_NOT, "NONE", 0, "None", ""},
{PART_DRAW_PATH, "PATH", 0, "Path", ""},
{PART_DRAW_OB, "OBJECT", 0, "Object", ""},
{PART_DRAW_GR, "GROUP", 0, "Group", ""},
{0, NULL, 0, NULL, NULL}
};
static EnumPropertyItem *rna_Particle_draw_as_itemf(PointerRNA *ptr)
@ -313,12 +313,12 @@ static void rna_def_particle(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem alive_items[] = {
{PARS_KILLED, "KILLED", "Killed", ""},
{PARS_DEAD, "DEAD", "Dead", ""},
{PARS_UNBORN, "UNBORN", "Unborn", ""},
{PARS_ALIVE, "ALIVE", "Alive", ""},
{PARS_DYING, "DYING", "Dying", ""},
{0, NULL, NULL, NULL}
{PARS_KILLED, "KILLED", 0, "Killed", ""},
{PARS_DEAD, "DEAD", 0, "Dead", ""},
{PARS_UNBORN, "UNBORN", 0, "Unborn", ""},
{PARS_ALIVE, "ALIVE", 0, "Alive", ""},
{PARS_DYING, "DYING", 0, "Dying", ""},
{0, NULL, 0, NULL, NULL}
};
srna = RNA_def_struct(brna, "Particle", NULL);
@ -453,115 +453,115 @@ static void rna_def_particle_settings(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem type_items[] = {
{PART_EMITTER, "EMITTER", "Emitter", ""},
{PART_REACTOR, "REACTOR", "Reactor", ""},
{PART_HAIR, "HAIR", "Hair", ""},
{0, NULL, NULL, NULL}
{PART_EMITTER, "EMITTER", 0, "Emitter", ""},
{PART_REACTOR, "REACTOR", 0, "Reactor", ""},
{PART_HAIR, "HAIR", 0, "Hair", ""},
{0, NULL, 0, NULL, NULL}
};
static EnumPropertyItem dist_items[] = {
{PART_DISTR_JIT, "JIT", "Jittered", ""},
{PART_DISTR_RAND, "RAND", "Random", ""},
{PART_DISTR_GRID, "GRID", "Grid", ""},
{0, NULL, NULL, NULL}
{PART_DISTR_JIT, "JIT", 0, "Jittered", ""},
{PART_DISTR_RAND, "RAND", 0, "Random", ""},
{PART_DISTR_GRID, "GRID", 0, "Grid", ""},
{0, NULL, 0, NULL, NULL}
};
static EnumPropertyItem phys_type_items[] = {
{PART_PHYS_NO, "NO", "No", ""},
{PART_PHYS_NEWTON, "NEWTON", "Newtonian", ""},
{PART_PHYS_KEYED, "KEYED", "Keyed", ""},
{PART_PHYS_BOIDS, "BOIDS", "Boids", ""},
{0, NULL, NULL, NULL}
{PART_PHYS_NO, "NO", 0, "No", ""},
{PART_PHYS_NEWTON, "NEWTON", 0, "Newtonian", ""},
{PART_PHYS_KEYED, "KEYED", 0, "Keyed", ""},
{PART_PHYS_BOIDS, "BOIDS", 0, "Boids", ""},
{0, NULL, 0, NULL, NULL}
};
static EnumPropertyItem rot_mode_items[] = {
{0, "NONE", "None", ""},
{PART_ROT_NOR, "NOR", "Normal", ""},
{PART_ROT_VEL, "VEL", "Velocity", ""},
{PART_ROT_GLOB_X, "GLOB_X", "Global X", ""},
{PART_ROT_GLOB_Y, "GLOB_Y", "Global Y", ""},
{PART_ROT_GLOB_Z, "GLOB_Z", "Global Z", ""},
{PART_ROT_OB_X, "OB_X", "Object X", ""},
{PART_ROT_OB_Y, "OB_Y", "Object Y", ""},
{PART_ROT_OB_Z, "OB_Z", "Object Z", ""},
{0, NULL, NULL, NULL}
{0, "NONE", 0, "None", ""},
{PART_ROT_NOR, "NOR", 0, "Normal", ""},
{PART_ROT_VEL, "VEL", 0, "Velocity", ""},
{PART_ROT_GLOB_X, "GLOB_X", 0, "Global X", ""},
{PART_ROT_GLOB_Y, "GLOB_Y", 0, "Global Y", ""},
{PART_ROT_GLOB_Z, "GLOB_Z", 0, "Global Z", ""},
{PART_ROT_OB_X, "OB_X", 0, "Object X", ""},
{PART_ROT_OB_Y, "OB_Y", 0, "Object Y", ""},
{PART_ROT_OB_Z, "OB_Z", 0, "Object Z", ""},
{0, NULL, 0, NULL, NULL}
};
static EnumPropertyItem ave_mode_items[] = {
{0, "NONE", "None", ""},
{PART_AVE_SPIN, "SPIN", "Spin", ""},
{PART_AVE_RAND, "RAND", "Random", ""} ,
{0, NULL, NULL, NULL}
{0, "NONE", 0, "None", ""},
{PART_AVE_SPIN, "SPIN", 0, "Spin", ""},
{PART_AVE_RAND, "RAND", 0, "Random", ""} ,
{0, NULL, 0, NULL, NULL}
};
static EnumPropertyItem react_event_items[] = {
{PART_EVENT_DEATH, "DEATH", "Death", ""},
{PART_EVENT_COLLIDE, "COLLIDE", "Collision", ""},
{PART_EVENT_NEAR, "NEAR", "Near", ""},
{0, NULL, NULL, NULL}
{PART_EVENT_DEATH, "DEATH", 0, "Death", ""},
{PART_EVENT_COLLIDE, "COLLIDE", 0, "Collision", ""},
{PART_EVENT_NEAR, "NEAR", 0, "Near", ""},
{0, NULL, 0, NULL, NULL}
};
static EnumPropertyItem child_type_items[] = {
{0, "NONE", "None", ""},
{PART_CHILD_PARTICLES, "PARTICLES", "Particles", ""},
{PART_CHILD_FACES, "FACES", "Faces", ""},
{0, NULL, NULL, NULL}
{0, "NONE", 0, "None", ""},
{PART_CHILD_PARTICLES, "PARTICLES", 0, "Particles", ""},
{PART_CHILD_FACES, "FACES", 0, "Faces", ""},
{0, NULL, 0, NULL, NULL}
};
//TODO: names, tooltips
static EnumPropertyItem rot_from_items[] = {
{PART_ROT_KEYS, "KEYS", "keys", ""},
{PART_ROT_ZINCR, "ZINCR", "zincr", ""},
{PART_ROT_IINCR, "IINCR", "iincr", ""},
{0, NULL, NULL, NULL}
{PART_ROT_KEYS, "KEYS", 0, "keys", ""},
{PART_ROT_ZINCR, "ZINCR", 0, "zincr", ""},
{PART_ROT_IINCR, "IINCR", 0, "iincr", ""},
{0, NULL, 0, NULL, NULL}
};
static EnumPropertyItem integrator_type_items[] = {
{PART_INT_EULER, "EULER", "Euler", ""},
{PART_INT_MIDPOINT, "MIDPOINT", "Midpoint", ""},
{PART_INT_RK4, "RK4", "RK4", ""},
{0, NULL, NULL, NULL}
{PART_INT_EULER, "EULER", 0, "Euler", ""},
{PART_INT_MIDPOINT, "MIDPOINT", 0, "Midpoint", ""},
{PART_INT_RK4, "RK4", 0, "RK4", ""},
{0, NULL, 0, NULL, NULL}
};
static EnumPropertyItem kink_type_items[] = {
{PART_KINK_NO, "NO", "Nothing", ""},
{PART_KINK_CURL, "CURL", "Curl", ""},
{PART_KINK_RADIAL, "RADIAL", "Radial", ""},
{PART_KINK_WAVE, "WAVE", "Wave", ""},
{PART_KINK_BRAID, "BRAID", "Braid", ""},
{0, NULL, NULL, NULL}
{PART_KINK_NO, "NO", 0, "Nothing", ""},
{PART_KINK_CURL, "CURL", 0, "Curl", ""},
{PART_KINK_RADIAL, "RADIAL", 0, "Radial", ""},
{PART_KINK_WAVE, "WAVE", 0, "Wave", ""},
{PART_KINK_BRAID, "BRAID", 0, "Braid", ""},
{0, NULL, 0, NULL, NULL}
};
static EnumPropertyItem kink_axis_items[] = {
{0, "X", "X", ""},
{1, "Y", "Y", ""},
{2, "Z", "Z", ""},
{0, NULL, NULL, NULL}
{0, "X", 0, "X", ""},
{1, "Y", 0, "Y", ""},
{2, "Z", 0, "Z", ""},
{0, NULL, 0, NULL, NULL}
};
static EnumPropertyItem bb_align_items[] = {
{PART_BB_X, "X", "X", ""},
{PART_BB_Y, "Y", "Y", ""},
{PART_BB_Z, "Z", "Z", ""},
{PART_BB_VIEW, "VIEW", "View", ""},
{PART_BB_VEL, "VEL", "Velocity", ""},
{0, NULL, NULL, NULL}
{PART_BB_X, "X", 0, "X", ""},
{PART_BB_Y, "Y", 0, "Y", ""},
{PART_BB_Z, "Z", 0, "Z", ""},
{PART_BB_VIEW, "VIEW", 0, "View", ""},
{PART_BB_VEL, "VEL", 0, "Velocity", ""},
{0, NULL, 0, NULL, NULL}
};
static EnumPropertyItem bb_anim_items[] = {
{PART_BB_ANIM_NONE, "NONE", "None", ""},
{PART_BB_ANIM_TIME, "TIME", "Time", ""},
{PART_BB_ANIM_ANGLE, "ANGLE", "Angle", ""},
//{PART_BB_ANIM_OFF_TIME, "OFF_TIME", "off_time", ""},
//{PART_BB_ANIM_OFF_ANGLE, "OFF_ANGLE", "off_angle", ""},
{0, NULL, NULL, NULL}
{PART_BB_ANIM_NONE, "NONE", 0, "None", ""},
{PART_BB_ANIM_TIME, "TIME", 0, "Time", ""},
{PART_BB_ANIM_ANGLE, "ANGLE", 0, "Angle", ""},
//{PART_BB_ANIM_OFF_TIME, "OFF_TIME", 0, "off_time", ""},
//{PART_BB_ANIM_OFF_ANGLE, "OFF_ANGLE", 0, "off_angle", ""},
{0, NULL, 0, NULL, NULL}
};
static EnumPropertyItem bb_split_offset_items[] = {
{PART_BB_OFF_NONE, "NONE", "None", ""},
{PART_BB_OFF_LINEAR, "LINEAR", "Linear", ""},
{PART_BB_OFF_RANDOM, "RANDOM", "Random", ""},
{0, NULL, NULL, NULL}
{PART_BB_OFF_NONE, "NONE", 0, "None", ""},
{PART_BB_OFF_LINEAR, "LINEAR", 0, "Linear", ""},
{PART_BB_OFF_RANDOM, "RANDOM", 0, "Random", ""},
{0, NULL, 0, NULL, NULL}
};
srna= RNA_def_struct(brna, "ParticleSettings", "ID");

6
source/blender/makesrna/intern/rna_pose.c
View File

@ -69,9 +69,9 @@ IDProperty *rna_PoseChannel_idproperties(PointerRNA *ptr, int create)
static void rna_def_pose_channel(BlenderRNA *brna)
{
static EnumPropertyItem prop_rotmode_items[] = {
{PCHAN_ROT_QUAT, "QUATERNION", "Quaternion (WXYZ)", "No Gimbal Lock (default)"},
{PCHAN_ROT_EUL, "EULER", "Euler (XYZ)", "Prone to Gimbal Lock"},
{0, NULL, NULL, NULL}};
{PCHAN_ROT_QUAT, "QUATERNION", 0, "Quaternion (WXYZ)", "No Gimbal Lock (default)"},
{PCHAN_ROT_EUL, "EULER", 0, "Euler (XYZ)", "Prone to Gimbal Lock"},
{0, NULL, 0, NULL, NULL}};
StructRNA *srna;
PropertyRNA *prop;

12
source/blender/makesrna/intern/rna_property.c
View File

@ -75,12 +75,12 @@ void RNA_def_gameproperty(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem gameproperty_type_items[] ={
{GPROP_BOOL, "BOOL", "Boolean", ""},
{GPROP_INT, "INT", "Integer", ""},
{GPROP_FLOAT, "FLOAT", "Float", ""},
{GPROP_STRING, "STRING", "String", ""},
{GPROP_TIME, "TIMER", "Timer", ""},
{0, NULL, NULL, NULL}};
{GPROP_BOOL, "BOOL", 0, "Boolean", ""},
{GPROP_INT, "INT", 0, "Integer", ""},
{GPROP_FLOAT, "FLOAT", 0, "Float", ""},
{GPROP_STRING, "STRING", 0, "String", ""},
{GPROP_TIME, "TIMER", 0, "Timer", ""},
{0, NULL, 0, NULL, NULL}};
/* Base Struct for GameProperty */
srna= RNA_def_struct(brna, "GameProperty", NULL);

8
source/blender/makesrna/intern/rna_radio.c
View File

@ -40,10 +40,10 @@ void RNA_def_radio(BlenderRNA *brna)
StructRNA *srna;
PropertyRNA *prop;
static EnumPropertyItem prop_drawtype_items[] = {
{RAD_WIREFRAME, "WIREFRAME", "Wireframe", "Enables Wireframe draw mode"},
{RAD_SOLID, "SOLID", "Solid", "Enables Solid draw mode"},
{RAD_GOURAUD, "GOURAUD", "Gouraud", "Enables Gouraud draw mode"},
{0, NULL, NULL, NULL}};
{RAD_WIREFRAME, "WIREFRAME", 0, "Wireframe", "Enables Wireframe draw mode"},
{RAD_SOLID, "SOLID", 0, "Solid", "Enables Solid draw mode"},
{RAD_GOURAUD, "GOURAUD", 0, "Gouraud", "Enables Gouraud draw mode"},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "Radiosity", NULL);
RNA_def_struct_ui_text(srna, "Radiosity", "Settings for radiosity simulation of indirect diffuse lighting.");

38
source/blender/makesrna/intern/rna_rna.c
View File

@ -626,26 +626,26 @@ static void rna_def_property(BlenderRNA *brna)
StructRNA *srna;
PropertyRNA *prop;
static EnumPropertyItem type_items[] = {
{PROP_BOOLEAN, "BOOLEAN", "Boolean", ""},
{PROP_INT, "INT", "Integer", ""},
{PROP_FLOAT, "FLOAT", "Float", ""},
{PROP_STRING, "STRING", "String", ""},
{PROP_ENUM, "ENUM", "Enumeration", ""},
{PROP_POINTER, "POINTER", "Pointer", ""},
{PROP_COLLECTION, "COLLECTION", "Collection", ""},
{0, NULL, NULL, NULL}};
{PROP_BOOLEAN, "BOOLEAN", 0, "Boolean", ""},
{PROP_INT, "INT", 0, "Integer", ""},
{PROP_FLOAT, "FLOAT", 0, "Float", ""},
{PROP_STRING, "STRING", 0, "String", ""},
{PROP_ENUM, "ENUM", 0, "Enumeration", ""},
{PROP_POINTER, "POINTER", 0, "Pointer", ""},
{PROP_COLLECTION, "COLLECTION", 0, "Collection", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem subtype_items[] = {
{PROP_NONE, "NONE", "None", ""},
{PROP_UNSIGNED, "UNSIGNED", "Unsigned Number", ""},
{PROP_FILEPATH, "FILE_PATH", "File Path", ""},
{PROP_DIRPATH, "DIRECTORY_PATH", "Directory Path", ""},
{PROP_COLOR, "COLOR", "Color", ""},
{PROP_VECTOR, "VECTOR", "Vector", ""},
{PROP_MATRIX, "MATRIX", "Matrix", ""},
{PROP_ROTATION, "ROTATION", "Rotation", ""},
{PROP_NEVER_NULL, "NEVER_NULL", "Never Null", ""},
{PROP_PERCENTAGE, "PERCENTAGE", "Percentage", ""},
{0, NULL, NULL, NULL}};
{PROP_NONE, "NONE", 0, "None", ""},
{PROP_UNSIGNED, "UNSIGNED", 0, "Unsigned Number", ""},
{PROP_FILEPATH, "FILE_PATH", 0, "File Path", ""},
{PROP_DIRPATH, "DIRECTORY_PATH", 0, "Directory Path", ""},
{PROP_COLOR, "COLOR", 0, "Color", ""},
{PROP_VECTOR, "VECTOR", 0, "Vector", ""},
{PROP_MATRIX, "MATRIX", 0, "Matrix", ""},
{PROP_ROTATION, "ROTATION", 0, "Rotation", ""},
{PROP_NEVER_NULL, "NEVER_NULL", 0, "Never Null", ""},
{PROP_PERCENTAGE, "PERCENTAGE", 0, "Percentage", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "Property", NULL);
RNA_def_struct_ui_text(srna, "Property Definition", "RNA property definition.");

238
source/blender/makesrna/intern/rna_scene.c
View File

@ -41,14 +41,14 @@
/* prop_mode needs to be accessible from transform operator */
EnumPropertyItem prop_mode_items[] ={
{PROP_SMOOTH, "SMOOTH", "Smooth", ""},
{PROP_SPHERE, "SPHERE", "Sphere", ""},
{PROP_ROOT, "ROOT", "Root", ""},
{PROP_SHARP, "SHARP", "Sharp", ""},
{PROP_LIN, "LINEAR", "Linear", ""},
{PROP_CONST, "CONSTANT", "Constant", ""},
{PROP_RANDOM, "RANDOM", "Random", ""},
{0, NULL, NULL, NULL}};
{PROP_SMOOTH, "SMOOTH", 0, "Smooth", ""},
{PROP_SPHERE, "SPHERE", 0, "Sphere", ""},
{PROP_ROOT, "ROOT", 0, "Root", ""},
{PROP_SHARP, "SHARP", 0, "Sharp", ""},
{PROP_LIN, "LINEAR", 0, "Linear", ""},
{PROP_CONST, "CONSTANT", 0, "Constant", ""},
{PROP_RANDOM, "RANDOM", 0, "Random", ""},
{0, NULL, 0, NULL, NULL}};
#ifdef RNA_RUNTIME
@ -172,161 +172,161 @@ void rna_def_scene_render_data(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem pixel_filter_items[] ={
{R_FILTER_BOX, "BOX", "Box", ""},
{R_FILTER_TENT, "TENT", "Tent", ""},
{R_FILTER_QUAD, "QUADRATIC", "Quadratic", ""},
{R_FILTER_CUBIC, "CUBIC", "Cubic", ""},
{R_FILTER_CATROM, "CATMULLROM", "Catmull-Rom", ""},
{R_FILTER_GAUSS, "GAUSSIAN", "Gaussian", ""},
{R_FILTER_MITCH, "MITCHELL", "Mitchell-Netravali", ""},
{0, NULL, NULL, NULL}};
{R_FILTER_BOX, "BOX", 0, "Box", ""},
{R_FILTER_TENT, "TENT", 0, "Tent", ""},
{R_FILTER_QUAD, "QUADRATIC", 0, "Quadratic", ""},
{R_FILTER_CUBIC, "CUBIC", 0, "Cubic", ""},
{R_FILTER_CATROM, "CATMULLROM", 0, "Catmull-Rom", ""},
{R_FILTER_GAUSS, "GAUSSIAN", 0, "Gaussian", ""},
{R_FILTER_MITCH, "MITCHELL", 0, "Mitchell-Netravali", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem alpha_mode_items[] ={
{R_ADDSKY, "SKY", "Sky", "Transparent pixels are filled with sky color"},
{R_ALPHAPREMUL, "PREMUL", "Premultiplied", "Transparent RGB pixels are multiplied by the alpha channel"},
{R_ALPHAKEY, "STRAIGHT", "Straight Alpha", "Transparent RGB and alpha pixels are unmodified"},
{0, NULL, NULL, NULL}};
{R_ADDSKY, "SKY", 0, "Sky", "Transparent pixels are filled with sky color"},
{R_ALPHAPREMUL, "PREMUL", 0, "Premultiplied", "Transparent RGB pixels are multiplied by the alpha channel"},
{R_ALPHAKEY, "STRAIGHT", 0, "Straight Alpha", "Transparent RGB and alpha pixels are unmodified"},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem color_mode_items[] ={
{R_PLANESBW, "BW", "BW", "Images are saved with BW (grayscale) data"},
{R_PLANES24, "RGB", "RGB", "Images are saved with RGB (color) data"},
{R_PLANES32, "RGBA", "RGBA", "Images are saved with RGB and Alpha data (if supported)"},
{0, NULL, NULL, NULL}};
{R_PLANESBW, "BW", 0, "BW", "Images are saved with BW (grayscale) data"},
{R_PLANES24, "RGB", 0, "RGB", "Images are saved with RGB (color) data"},
{R_PLANES32, "RGBA", 0, "RGBA", "Images are saved with RGB and Alpha data (if supported)"},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem octree_resolution_items[] = {
{64, "OCTREE_RES_64", "64", ""},
{128, "OCTREE_RES_128", "128", ""},
{256, "OCTREE_RES_256", "256", ""},
{512, "OCTREE_RES_512", "512", ""},
{0, NULL, NULL, NULL}};
{64, "OCTREE_RES_64", 0, "64", ""},
{128, "OCTREE_RES_128", 0, "128", ""},
{256, "OCTREE_RES_256", 0, "256", ""},
{512, "OCTREE_RES_512", 0, "512", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem fixed_oversample_items[] = {
{5, "OVERSAMPLE_5", "5", ""},
{8, "OVERSAMPLE_8", "8", ""},
{11, "OVERSAMPLE_11", "11", ""},
{16, "OVERSAMPLE_16", "16", ""},
{0, NULL, NULL, NULL}};
{5, "OVERSAMPLE_5", 0, "5", ""},
{8, "OVERSAMPLE_8", 0, "8", ""},
{11, "OVERSAMPLE_11", 0, "11", ""},
{16, "OVERSAMPLE_16", 0, "16", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem field_order_items[] = {
{0, "FIELDS_EVENFIRST", "Even", "Even Fields First"},
{R_ODDFIELD, "FIELDS_ODDFIRST", "Odd", "Odd Fields First"},
{0, NULL, NULL, NULL}};
{0, "FIELDS_EVENFIRST", 0, "Even", "Even Fields First"},
{R_ODDFIELD, "FIELDS_ODDFIRST", 0, "Odd", "Odd Fields First"},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem threads_mode_items[] = {
{0, "THREADS_AUTO", "Auto-detect", "Automatically determine the number of threads, based on CPUs"},
{R_FIXED_THREADS, "THREADS_FIXED", "Fixed", "Manually determine the number of threads"},
{0, NULL, NULL, NULL}};
{0, "THREADS_AUTO", 0, "Auto-detect", "Automatically determine the number of threads, based on CPUs"},
{R_FIXED_THREADS, "THREADS_FIXED", 0, "Fixed", "Manually determine the number of threads"},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem stamp_font_size_items[] = {
{1, "STAMP_FONT_TINY", "Tiny", ""},
{2, "STAMP_FONT_SMALL", "Small", ""},
{3, "STAMP_FONT_MEDIUM", "Medium", ""},
{0, "STAMP_FONT_LARGE", "Large", ""},
{4, "STAMP_FONT_EXTRALARGE", "Extra Large", ""},
{0, NULL, NULL, NULL}};
{1, "STAMP_FONT_TINY", 0, "Tiny", ""},
{2, "STAMP_FONT_SMALL", 0, "Small", ""},
{3, "STAMP_FONT_MEDIUM", 0, "Medium", ""},
{0, "STAMP_FONT_LARGE", 0, "Large", ""},
{4, "STAMP_FONT_EXTRALARGE", 0, "Extra Large", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem image_type_items[] = {
{R_FRAMESERVER, "FRAMESERVER", "Frame Server", ""},
{R_FRAMESERVER, "FRAMESERVER", 0, "Frame Server", ""},
#ifdef WITH_FFMPEG
{R_FFMPEG, "FFMPEG", "FFMpeg", ""},
{R_FFMPEG, "FFMPEG", 0, "FFMpeg", ""},
#endif
{R_AVIRAW, "AVIRAW", "AVI Raw", ""},
{R_AVIJPEG, "AVIJPEG", "AVI JPEG", ""},
{R_AVIRAW, "AVIRAW", 0, "AVI Raw", ""},
{R_AVIJPEG, "AVIJPEG", 0, "AVI JPEG", ""},
#ifdef _WIN32
{R_AVICODEC, "AVICODEC", "AVI Codec", ""},
{R_AVICODEC, "AVICODEC", 0, "AVI Codec", ""},
#endif
#ifdef WITH_QUICKTIME
{R_QUICKTIME, "QUICKTIME", "QuickTime", ""},
{R_QUICKTIME, "QUICKTIME", 0, "QuickTime", ""},
#endif
{R_TARGA, "TARGA", "Targa", ""},
{R_RAWTGA, "RAWTARGA", "Targa Raw", ""},
{R_PNG, "PNG", "PNG", ""},
//{R_DDS, "DDS", "DDS", ""}, // XXX not yet implemented
{R_TARGA, "TARGA", 0, "Targa", ""},
{R_RAWTGA, "RAWTARGA", 0, "Targa Raw", ""},
{R_PNG, "PNG", 0, "PNG", ""},
//{R_DDS, "DDS", 0, "DDS", ""}, // XXX not yet implemented
//#ifdef WITH_OPENJPEG
{R_JP2, "JPEG2000", "JPEG 2000", ""},
{R_JP2, "JPEG2000", 0, "JPEG 2000", ""},
//#endif
{R_BMP, "BMP", "BMP", ""},
{R_JPEG90, "JPEG", "JPEG", ""},
{R_HAMX, "HAMX", "HamX", ""},
{R_IRIS, "IRIS", "Iris", ""},
{R_RADHDR, "RADHDR", "Radiance HDR", ""},
{R_CINEON, "CINEON", "Cineon", ""},
{R_DPX, "DPX", "DPX", ""},
{R_BMP, "BMP", 0, "BMP", ""},
{R_JPEG90, "JPEG", 0, "JPEG", ""},
{R_HAMX, "HAMX", 0, "HamX", ""},
{R_IRIS, "IRIS", 0, "Iris", ""},
{R_RADHDR, "RADHDR", 0, "Radiance HDR", ""},
{R_CINEON, "CINEON", 0, "Cineon", ""},
{R_DPX, "DPX", 0, "DPX", ""},
#ifdef __sgi
{R_MOVIE, "MOVIE", "Movie", ""},
{R_MOVIE, "MOVIE", 0, "Movie", ""},
#endif
//#ifdef WITH_OPENEXR
{R_OPENEXR, "OPENEXR", "OpenEXR", ""},
{R_MULTILAYER, "MULTILAYER", "MultiLayer", ""},
{R_OPENEXR, "OPENEXR", 0, "OpenEXR", ""},
{R_MULTILAYER, "MULTILAYER", 0, "MultiLayer", ""},
//#endif
{R_TIFF, "TIFF", "TIFF", ""}, // XXX only with G.have_libtiff
{0, NULL, NULL, NULL}};
{R_TIFF, "TIFF", 0, "TIFF", ""}, // XXX only with G.have_libtiff
{0, NULL, 0, NULL, NULL}};
//#ifdef WITH_OPENEXR
static EnumPropertyItem exr_codec_items[] = {
{0, "NONE", "None", ""},
{1, "PXR24", "Pxr24 (lossy)", ""},
{2, "ZIP", "ZIP (lossless)", ""},
{3, "PIZ", "PIZ (lossless)", ""},
{4, "RLE", "RLE (lossless)", ""},
{0, NULL, NULL, NULL}};
{0, "NONE", 0, "None", ""},
{1, "PXR24", 0, "Pxr24 (lossy)", ""},
{2, "ZIP", 0, "ZIP (lossless)", ""},
{3, "PIZ", 0, "PIZ (lossless)", ""},
{4, "RLE", 0, "RLE (lossless)", ""},
{0, NULL, 0, NULL, NULL}};
//#endif
//#ifdef WITH_OPENJPEG
static EnumPropertyItem jp2_preset_items[] = {
{0, "NO_PRESET", "No Preset", ""},
{1, "R_JPEG2K_CINE_PRESET", "Cinema 24fps 2048x1080", ""},
{2, "R_JPEG2K_CINE_PRESET|R_JPEG2K_CINE_48FPS", "Cinema 48fps 2048x1080", ""},
{3, "R_JPEG2K_CINE_PRESET", "Cinema 24fps 4096x2160", ""},
{4, "R_JPEG2K_CINE_PRESET", "Cine-Scope 24fps 2048x858", ""},
{5, "R_JPEG2K_CINE_PRESET|R_JPEG2K_CINE_48FPS", "Cine-Scope 48fps 2048x858", ""},
{6, "R_JPEG2K_CINE_PRESET", "Cine-Flat 24fps 1998x1080", ""},
{7, "R_JPEG2K_CINE_PRESET|R_JPEG2K_CINE_48FPS", "Cine-Flat 48fps 1998x1080", ""},
{0, NULL, NULL, NULL}};
{0, "NO_PRESET", 0, "No Preset", ""},
{1, "R_JPEG2K_CINE_PRESET", 0, "Cinema 24fps 2048x1080", ""},
{2, "R_JPEG2K_CINE_PRESET|R_JPEG2K_CINE_48FPS", 0, "Cinema 48fps 2048x1080", ""},
{3, "R_JPEG2K_CINE_PRESET", 0, "Cinema 24fps 4096x2160", ""},
{4, "R_JPEG2K_CINE_PRESET", 0, "Cine-Scope 24fps 2048x858", ""},
{5, "R_JPEG2K_CINE_PRESET|R_JPEG2K_CINE_48FPS", 0, "Cine-Scope 48fps 2048x858", ""},
{6, "R_JPEG2K_CINE_PRESET", 0, "Cine-Flat 24fps 1998x1080", ""},
{7, "R_JPEG2K_CINE_PRESET|R_JPEG2K_CINE_48FPS", 0, "Cine-Flat 48fps 1998x1080", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem jp2_depth_items[] = {
{0, "8", "8", ""},
{R_JPEG2K_12BIT, "16", "16", ""},
{R_JPEG2K_16BIT, "32", "32", ""},
{0, NULL, NULL, NULL}};
{0, "8", 0, "8", ""},
{R_JPEG2K_12BIT, "16", 0, "16", ""},
{R_JPEG2K_16BIT, "32", 0, "32", ""},
{0, NULL, 0, NULL, NULL}};
//#endif
/*
#ifdef WITH_FFMPEG
static EnumPropertyItem ffmpeg_format_items[] = {
{FFMPEG_MPEG1, "MPEG1", "MPEG-1", ""},
{FFMPEG_MPEG2, "MPEG2", "MPEG-2", ""},
{FFMPEG_MPEG4, "MPEG4", "MPEG-4", ""},
{FFMPEG_AVI, "AVI", "Avi", ""},
{FFMPEG_MOV, "QUICKTIME", "Quicktime", ""},
{FFMPEG_DV, "DV", "DV", ""},
{FFMPEG_H264, "H264", "H264", ""},
{FFMPEG_XVID, "XVID", "XVid", ""},
{FFMPEG_OGG, "OGG", "OGG", ""},
{FFMPEG_FLV, "FLASH", "Flash", ""},
{0, NULL, NULL, NULL}};
{FFMPEG_MPEG1, "MPEG1", 0, "MPEG-1", ""},
{FFMPEG_MPEG2, "MPEG2", 0, "MPEG-2", ""},
{FFMPEG_MPEG4, "MPEG4", 0, "MPEG-4", ""},
{FFMPEG_AVI, "AVI", 0, "Avi", ""},
{FFMPEG_MOV, "QUICKTIME", 0, "Quicktime", ""},
{FFMPEG_DV, "DV", 0, "DV", ""},
{FFMPEG_H264, "H264", 0, "H264", ""},
{FFMPEG_XVID, "XVID", 0, "XVid", ""},
{FFMPEG_OGG, "OGG", 0, "OGG", ""},
{FFMPEG_FLV, "FLASH", 0, "Flash", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem ffmpeg_codec_items[] = {
{CODEC_ID_MPEG1VIDEO, "MPEG1", "MPEG-1", ""},
{CODEC_ID_MPEG2VIDEO, "MPEG2", "MPEG-2", ""},
{CODEC_ID_MPEG4, "MPEG4", "MPEG-4(divx)", ""},
{CODEC_ID_HUFFYUV, "HUFFYUV", "HuffYUV", ""},
{CODEC_ID_DVVIDEO, "DV", "DV", ""},
{CODEC_ID_H264, "H264", "H264", ""},
{CODEC_ID_XVID, "XVID", "XVid", ""},
{CODEC_ID_THEORA, "THEORA", "OGG Theora", ""},
{CODEC_ID_FLV1, "FLASH", "FlashVideo1", ""},
{0, NULL, NULL, NULL}};
{CODEC_ID_MPEG1VIDEO, "MPEG1", 0, "MPEG-1", ""},
{CODEC_ID_MPEG2VIDEO, "MPEG2", 0, "MPEG-2", ""},
{CODEC_ID_MPEG4, "MPEG4", 0, "MPEG-4(divx)", ""},
{CODEC_ID_HUFFYUV, "HUFFYUV", 0, "HuffYUV", ""},
{CODEC_ID_DVVIDEO, "DV", 0, "DV", ""},
{CODEC_ID_H264, "H264", 0, "H264", ""},
{CODEC_ID_XVID, "XVID", 0, "XVid", ""},
{CODEC_ID_THEORA, "THEORA", 0, "OGG Theora", ""},
{CODEC_ID_FLV1, "FLASH", 0, "FlashVideo1", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem ffmpeg_audio_codec_items[] = {
{CODEC_ID_MP2, "MP2", "MP2", ""},
{CODEC_ID_MP3, "MP3", "MP3", ""},
{CODEC_ID_AC3, "AC3", "AC3", ""},
{CODEC_ID_AAC, "AAC", "AAC", ""},
{CODEC_ID_VORBIS, "VORBIS", "Vorbis", ""},
{CODEC_ID_PCM_S16LE, "PCM", "PCM", ""},
{0, NULL, NULL, NULL}};
{CODEC_ID_MP2, "MP2", 0, "MP2", ""},
{CODEC_ID_MP3, "MP3", 0, "MP3", ""},
{CODEC_ID_AC3, "AC3", 0, "AC3", ""},
{CODEC_ID_AAC, "AAC", 0, "AAC", ""},
{CODEC_ID_VORBIS, "VORBIS", 0, "Vorbis", ""},
{CODEC_ID_PCM_S16LE, "PCM", 0, "PCM", ""},
{0, NULL, 0, NULL, NULL}};
#endif
*/
@ -840,9 +840,9 @@ void RNA_def_scene(BlenderRNA *brna)
StructRNA *srna;
PropertyRNA *prop;
static EnumPropertyItem unwrapper_items[] = {
{0, "CONFORMAL", "Conformal", ""},
{1, "ANGLEBASED", "Angle Based", ""},
{0, NULL, NULL, NULL}};
{0, "CONFORMAL", 0, "Conformal", ""},
{1, "ANGLEBASED", 0, "Angle Based", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "Scene", "ID");
RNA_def_struct_ui_text(srna, "Scene", "Scene consisting objects and defining time and render related settings.");

12
source/blender/makesrna/intern/rna_screen.c
View File

@ -33,12 +33,12 @@
#include "DNA_scene_types.h"
EnumPropertyItem region_type_items[] = {
{RGN_TYPE_WINDOW, "WINDOW", "Window", ""},
{RGN_TYPE_HEADER, "HEADER", "Header", ""},
{RGN_TYPE_CHANNELS, "CHANNELS", "Channels", ""},
{RGN_TYPE_TEMPORARY, "TEMPORARY", "Temporary", ""},
{RGN_TYPE_UI, "UI", "UI", ""},
{0, NULL, NULL, NULL}};
{RGN_TYPE_WINDOW, "WINDOW", 0, "Window", ""},
{RGN_TYPE_HEADER, "HEADER", 0, "Header", ""},
{RGN_TYPE_CHANNELS, "CHANNELS", 0, "Channels", ""},
{RGN_TYPE_TEMPORARY, "TEMPORARY", 0, "Temporary", ""},
{RGN_TYPE_UI, "UI", 0, "UI", ""},
{0, NULL, 0, NULL, NULL}};
#ifdef RNA_RUNTIME

118
source/blender/makesrna/intern/rna_sensor.c
View File

@ -78,21 +78,21 @@ void rna_def_sensor(BlenderRNA *brna)
StructRNA *srna;
PropertyRNA *prop;
static EnumPropertyItem sensor_type_items[] ={
{SENS_ALWAYS, "ALWAYS", "Always", ""},
{SENS_TOUCH, "TOUCH", "Touch", ""},
{SENS_NEAR, "NEAR", "Near", ""},
{SENS_KEYBOARD, "KEYBOARD", "Keyboard", ""},
{SENS_PROPERTY, "PROPERTY", "Property", ""},
{SENS_MOUSE, "MOUSE", "Mouse", ""},
{SENS_COLLISION, "COLLISION", "Collision", ""},
{SENS_RADAR, "RADAR", "Radar", ""},
{SENS_RANDOM, "RANDOM", "Random", ""},
{SENS_RAY, "RAY", "Ray", ""},
{SENS_MESSAGE, "MESSAGE", "Message", ""},
{SENS_JOYSTICK, "JOYSTICK", "joystick", ""},
{SENS_ACTUATOR, "ACTUATOR", "Actuator", ""},
{SENS_DELAY, "DELAY", "Delay", ""},
{0, NULL, NULL, NULL}};
{SENS_ALWAYS, "ALWAYS", 0, "Always", ""},
{SENS_TOUCH, "TOUCH", 0, "Touch", ""},
{SENS_NEAR, "NEAR", 0, "Near", ""},
{SENS_KEYBOARD, "KEYBOARD", 0, "Keyboard", ""},
{SENS_PROPERTY, "PROPERTY", 0, "Property", ""},
{SENS_MOUSE, "MOUSE", 0, "Mouse", ""},
{SENS_COLLISION, "COLLISION", 0, "Collision", ""},
{SENS_RADAR, "RADAR", 0, "Radar", ""},
{SENS_RANDOM, "RANDOM", 0, "Random", ""},
{SENS_RAY, "RAY", 0, "Ray", ""},
{SENS_MESSAGE, "MESSAGE", 0, "Message", ""},
{SENS_JOYSTICK, "JOYSTICK", 0, "joystick", ""},
{SENS_ACTUATOR, "ACTUATOR", 0, "Actuator", ""},
{SENS_DELAY, "DELAY", 0, "Delay", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "Sensor", NULL);
RNA_def_struct_ui_text(srna, "Sensor", "Game engine logic brick to detect events.");
@ -166,15 +166,15 @@ void rna_def_mouse_sensor(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem mouse_event_items[] ={
{BL_SENS_MOUSE_LEFT_BUTTON, "LEFTCLICK", "Left Button", ""},
{BL_SENS_MOUSE_MIDDLE_BUTTON, "MIDDLECLICK", "Middle Button", ""},
{BL_SENS_MOUSE_RIGHT_BUTTON, "RIGHTCLICK", "Right Button", ""},
{BL_SENS_MOUSE_WHEEL_UP, "WHEELUP", "Wheel Up", ""},
{BL_SENS_MOUSE_WHEEL_DOWN, "WHEELDOWN", "Wheel Down", ""},
{BL_SENS_MOUSE_MOVEMENT, "MOVEMENT", "Movement", ""},
{BL_SENS_MOUSE_MOUSEOVER, "MOUSEOVER", "Mouse Over", ""},
{BL_SENS_MOUSE_MOUSEOVER_ANY, "MOUSEOVERANY", "Mouse Over Any", ""},
{0, NULL, NULL, NULL}};
{BL_SENS_MOUSE_LEFT_BUTTON, "LEFTCLICK", 0, "Left Button", ""},
{BL_SENS_MOUSE_MIDDLE_BUTTON, "MIDDLECLICK", 0, "Middle Button", ""},
{BL_SENS_MOUSE_RIGHT_BUTTON, "RIGHTCLICK", 0, "Right Button", ""},
{BL_SENS_MOUSE_WHEEL_UP, "WHEELUP", 0, "Wheel Up", ""},
{BL_SENS_MOUSE_WHEEL_DOWN, "WHEELDOWN", 0, "Wheel Down", ""},
{BL_SENS_MOUSE_MOVEMENT, "MOVEMENT", 0, "Movement", ""},
{BL_SENS_MOUSE_MOUSEOVER, "MOUSEOVER", 0, "Mouse Over", ""},
{BL_SENS_MOUSE_MOUSEOVER_ANY, "MOUSEOVERANY", 0, "Mouse Over Any", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "MouseSensor", "Sensor");
RNA_def_struct_ui_text(srna, "Mouse Sensor", "Sensor to detect mouse events.");
@ -245,12 +245,12 @@ void rna_def_property_sensor(BlenderRNA *brna)
StructRNA *srna;
PropertyRNA *prop;
static EnumPropertyItem prop_type_items[] ={
{SENS_PROP_EQUAL, "PROPEQUAL", "Equal", ""},
{SENS_PROP_NEQUAL, "PROPNEQUAL", "Not Equal", ""},
{SENS_PROP_INTERVAL, "PROPINTERVAL", "Interval", ""},
{SENS_PROP_CHANGED, "PROPCHANGED", "Changed", ""},
/* {SENS_PROP_EXPRESSION, "PROPEXPRESSION", "Expression", ""}, NOT_USED_IN_UI */
{0, NULL, NULL, NULL}};
{SENS_PROP_EQUAL, "PROPEQUAL", 0, "Equal", ""},
{SENS_PROP_NEQUAL, "PROPNEQUAL", 0, "Not Equal", ""},
{SENS_PROP_INTERVAL, "PROPINTERVAL", 0, "Interval", ""},
{SENS_PROP_CHANGED, "PROPCHANGED", 0, "Changed", ""},
/* {SENS_PROP_EXPRESSION, "PROPEXPRESSION", 0, "Expression", ""}, NOT_USED_IN_UI */
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "PropertySensor", "Sensor");
RNA_def_struct_ui_text(srna, "Property Sensor", "Sensor to detect values and changes in values of properties.");
@ -319,9 +319,9 @@ void rna_def_collision_sensor(BlenderRNA *brna)
StructRNA *srna;
PropertyRNA *prop;
static EnumPropertyItem prop_type_items[] ={
{0, "PROPERTY", "Property", ""},
{1, "MATERIAL", "Material", ""},
{0, NULL, NULL, NULL}};
{0, "PROPERTY", 0, "Property", ""},
{1, "MATERIAL", 0, "Material", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "CollisionSensor", "Sensor");
RNA_def_struct_ui_text(srna, "Collision Sensor", "Sensor to detect objects colliding with the current object, with more settings than the Touch sensor.");
@ -346,13 +346,13 @@ void rna_def_radar_sensor(BlenderRNA *brna)
StructRNA *srna;
PropertyRNA *prop;
static EnumPropertyItem axis_items[] ={
{SENS_RAY_X_AXIS, "XAXIS", "+X axis", ""},
{SENS_RAY_Y_AXIS, "YAXIS", "+Y axis", ""},
{SENS_RAY_Z_AXIS, "ZAXIS", "+Z axis", ""},
{SENS_RAY_NEG_X_AXIS, "NEGXAXIS", "-X axis", ""},
{SENS_RAY_NEG_Y_AXIS, "NEGYAXIS", "-Y axis", ""},
{SENS_RAY_NEG_Z_AXIS, "NEGZAXIS", "-Z axis", ""},
{0, NULL, NULL, NULL}};
{SENS_RAY_X_AXIS, "XAXIS", 0, "+X axis", ""},
{SENS_RAY_Y_AXIS, "YAXIS", 0, "+Y axis", ""},
{SENS_RAY_Z_AXIS, "ZAXIS", 0, "+Z axis", ""},
{SENS_RAY_NEG_X_AXIS, "NEGXAXIS", 0, "-X axis", ""},
{SENS_RAY_NEG_Y_AXIS, "NEGYAXIS", 0, "-Y axis", ""},
{SENS_RAY_NEG_Z_AXIS, "NEGZAXIS", 0, "-Z axis", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "RadarSensor", "Sensor");
RNA_def_struct_ui_text(srna, "Radar Sensor", "Sensor to detect objects in a cone shaped radar emanating from the current object.");
@ -395,17 +395,17 @@ void rna_def_ray_sensor(BlenderRNA *brna)
StructRNA *srna;
PropertyRNA *prop;
static EnumPropertyItem axis_items[] ={
{SENS_RAY_X_AXIS, "XAXIS", "+X axis", ""},
{SENS_RAY_Y_AXIS, "YAXIS", "+Y axis", ""},
{SENS_RAY_Z_AXIS, "ZAXIS", "+Z axis", ""},
{SENS_RAY_NEG_X_AXIS, "NEGXAXIS", "-X axis", ""},
{SENS_RAY_NEG_Y_AXIS, "NEGYAXIS", "-Y axis", ""},
{SENS_RAY_NEG_Z_AXIS, "NEGZAXIS", "-Z axis", ""},
{0, NULL, NULL, NULL}};
{SENS_RAY_X_AXIS, "XAXIS", 0, "+X axis", ""},
{SENS_RAY_Y_AXIS, "YAXIS", 0, "+Y axis", ""},
{SENS_RAY_Z_AXIS, "ZAXIS", 0, "+Z axis", ""},
{SENS_RAY_NEG_X_AXIS, "NEGXAXIS", 0, "-X axis", ""},
{SENS_RAY_NEG_Y_AXIS, "NEGYAXIS", 0, "-Y axis", ""},
{SENS_RAY_NEG_Z_AXIS, "NEGZAXIS", 0, "-Z axis", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem prop_type_items[] ={
{0, "PROPERTY", "Property", ""},
{1, "MATERIAL", "Material", ""},
{0, NULL, NULL, NULL}};
{0, "PROPERTY", 0, "Property", ""},
{1, "MATERIAL", 0, "Material", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "RaySensor", "Sensor");
RNA_def_struct_ui_text(srna, "Ray Sensor", "Sensor to detect intersections with a ray emanating from the current object.");
@ -457,17 +457,17 @@ void rna_def_joystick_sensor(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem event_type_items[] ={
{SENS_JOY_BUTTON, "BUTTON", "Button", ""},
{SENS_JOY_AXIS, "AXIS", "Axis", ""},
{SENS_JOY_HAT, "HAT", "Hat", ""},
{0, NULL, NULL, NULL}};
{SENS_JOY_BUTTON, "BUTTON", 0, "Button", ""},
{SENS_JOY_AXIS, "AXIS", 0, "Axis", ""},
{SENS_JOY_HAT, "HAT", 0, "Hat", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem axis_direction_items[] ={
{SENS_JOY_X_AXIS, "RIGHTAXIS", "Right Axis", ""},
{SENS_JOY_Y_AXIS, "UPAXIS", "Up Axis", ""},
{SENS_JOY_NEG_X_AXIS, "LEFTAXIS", "Left Axis", ""},
{SENS_JOY_NEG_Y_AXIS, "DOWNAXIS", "Down Axis", ""},
{0, NULL, NULL, NULL}};
{SENS_JOY_X_AXIS, "RIGHTAXIS", 0, "Right Axis", ""},
{SENS_JOY_Y_AXIS, "UPAXIS", 0, "Up Axis", ""},
{SENS_JOY_NEG_X_AXIS, "LEFTAXIS", 0, "Left Axis", ""},
{SENS_JOY_NEG_Y_AXIS, "DOWNAXIS", 0, "Down Axis", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "JoystickSensor", "Sensor");
RNA_def_struct_ui_text(srna, "Joystick Sensor", "Sensor to detect joystick events.");

102
source/blender/makesrna/intern/rna_sequence.c
View File

@ -40,6 +40,8 @@
#ifdef RNA_RUNTIME
#include "MEM_guardedalloc.h"
static int rna_SequenceEditor_name_length(PointerRNA *ptr)
{
return strlen("Sequence Editor");
@ -356,41 +358,41 @@ static void rna_def_sequence(BlenderRNA *brna)
FunctionRNA *func;
static const EnumPropertyItem seq_type_items[]= {
{SEQ_IMAGE, "IMAGE", "Image", ""},
{SEQ_META, "META", "Meta", ""},
{SEQ_SCENE, "SCENE", "Scene", ""},
{SEQ_MOVIE, "MOVIE", "Movie", ""},
{SEQ_RAM_SOUND, "RAM_SOUND", "Ram Sound", ""},
{SEQ_HD_SOUND, "HD_SOUND", "HD Sound", ""},
{SEQ_MOVIE_AND_HD_SOUND, "MOVIE_AND_HD_SOUND", "Movie and HD Sound", ""},
{SEQ_EFFECT, "REPLACE", "Replace", ""},
{SEQ_CROSS, "CROSS", "Cross", ""},
{SEQ_ADD, "ADD", "Add", ""},
{SEQ_SUB, "SUBTRACT", "Subtract", ""},
{SEQ_ALPHAOVER, "ALPHA_OVER", "Alpha Over", ""},
{SEQ_ALPHAUNDER, "ALPHA_UNDER", "Alpha Under", ""},
{SEQ_GAMCROSS, "GAMMA_CROSS", "Gamma Cross", ""},
{SEQ_MUL, "MULTIPLY", "Multiply", ""},
{SEQ_OVERDROP, "OVER_DROP", "Over Drop", ""},
{SEQ_PLUGIN, "PLUGIN", "plugin", ""},
{SEQ_WIPE, "WIPE", "Wipe", ""},
{SEQ_GLOW, "GLOW", "Glow", ""},
{SEQ_TRANSFORM, "TRANSFORM", "Transform", ""},
{SEQ_COLOR, "COLOR", "Color", ""},
{SEQ_SPEED, "SPEED", "Speed", ""},
{0, NULL, NULL, NULL}};
{SEQ_IMAGE, "IMAGE", 0, "Image", ""},
{SEQ_META, "META", 0, "Meta", ""},
{SEQ_SCENE, "SCENE", 0, "Scene", ""},
{SEQ_MOVIE, "MOVIE", 0, "Movie", ""},
{SEQ_RAM_SOUND, "RAM_SOUND", 0, "Ram Sound", ""},
{SEQ_HD_SOUND, "HD_SOUND", 0, "HD Sound", ""},
{SEQ_MOVIE_AND_HD_SOUND, "MOVIE_AND_HD_SOUND", 0, "Movie and HD Sound", ""},
{SEQ_EFFECT, "REPLACE", 0, "Replace", ""},
{SEQ_CROSS, "CROSS", 0, "Cross", ""},
{SEQ_ADD, "ADD", 0, "Add", ""},
{SEQ_SUB, "SUBTRACT", 0, "Subtract", ""},
{SEQ_ALPHAOVER, "ALPHA_OVER", 0, "Alpha Over", ""},
{SEQ_ALPHAUNDER, "ALPHA_UNDER", 0, "Alpha Under", ""},
{SEQ_GAMCROSS, "GAMMA_CROSS", 0, "Gamma Cross", ""},
{SEQ_MUL, "MULTIPLY", 0, "Multiply", ""},
{SEQ_OVERDROP, "OVER_DROP", 0, "Over Drop", ""},
{SEQ_PLUGIN, "PLUGIN", 0, "plugin", ""},
{SEQ_WIPE, "WIPE", 0, "Wipe", ""},
{SEQ_GLOW, "GLOW", 0, "Glow", ""},
{SEQ_TRANSFORM, "TRANSFORM", 0, "Transform", ""},
{SEQ_COLOR, "COLOR", 0, "Color", ""},
{SEQ_SPEED, "SPEED", 0, "Speed", ""},
{0, NULL, 0, NULL, NULL}};
static const EnumPropertyItem blend_mode_items[]= {
{SEQ_BLEND_REPLACE, "REPLACE", "Replace", ""},
{SEQ_CROSS, "CROSS", "Cross", ""},
{SEQ_ADD, "ADD", "Add", ""},
{SEQ_SUB, "SUBTRACT", "Subtract", ""},
{SEQ_ALPHAOVER, "ALPHA_OVER", "Alpha Over", ""},
{SEQ_ALPHAUNDER, "ALPHA_UNDER", "Alpha Under", ""},
{SEQ_GAMCROSS, "GAMMA_CROSS", "Gamma Cross", ""},
{SEQ_MUL, "MULTIPLY", "Multiply", ""},
{SEQ_OVERDROP, "OVER_DROP", "Over Drop", ""},
{0, NULL, NULL, NULL}};
{SEQ_BLEND_REPLACE, "REPLACE", 0, "Replace", ""},
{SEQ_CROSS, "CROSS", 0, "Cross", ""},
{SEQ_ADD, "ADD", 0, "Add", ""},
{SEQ_SUB, "SUBTRACT", 0, "Subtract", ""},
{SEQ_ALPHAOVER, "ALPHA_OVER", 0, "Alpha Over", ""},
{SEQ_ALPHAUNDER, "ALPHA_UNDER", 0, "Alpha Under", ""},
{SEQ_GAMCROSS, "GAMMA_CROSS", 0, "Gamma Cross", ""},
{SEQ_MUL, "MULTIPLY", 0, "Multiply", ""},
{SEQ_OVERDROP, "OVER_DROP", 0, "Over Drop", ""},
{0, NULL, 0, NULL, NULL}};
srna = RNA_def_struct(brna, "Sequence", NULL);
RNA_def_struct_ui_text(srna, "Sequence", "Sequence strip in the sequence editor.");
@ -785,19 +787,19 @@ static void rna_def_wipe(BlenderRNA *brna)
PropertyRNA *prop;
static const EnumPropertyItem wipe_type_items[]= {
{0, "SINGLE", "Single", ""},
{1, "DOUBLE", "Double", ""},
/* not used yet {2, "BOX", "Box", ""}, */
/* not used yet {3, "CROSS", "Cross", ""}, */
{4, "IRIS", "Iris", ""},
{5, "CLOCK", "Clock", ""},
{0, NULL, NULL, NULL}
{0, "SINGLE", 0, "Single", ""},
{1, "DOUBLE", 0, "Double", ""},
/* not used yet {2, "BOX", 0, "Box", ""}, */
/* not used yet {3, "CROSS", 0, "Cross", ""}, */
{4, "IRIS", 0, "Iris", ""},
{5, "CLOCK", 0, "Clock", ""},
{0, NULL, 0, NULL, NULL}
};
static const EnumPropertyItem wipe_direction_items[]= {
{0, "OUT", "Out", ""},
{1, "IN", "In", ""},
{0, NULL, NULL, NULL}
{0, "OUT", 0, "Out", ""},
{1, "IN", 0, "In", ""},
{0, NULL, 0, NULL, NULL}
};
srna = RNA_def_struct(brna, "WipeSequence", "EffectSequence");
@ -870,16 +872,16 @@ static void rna_def_transform(BlenderRNA *brna)
PropertyRNA *prop;
static const EnumPropertyItem interpolation_items[]= {
{0, "NONE", "None", "No interpolation."},
{1, "BILINEAR", "Bilinear", "Bilinear interpolation."},
{2, "BICUBIC", "Bicubic", "Bicubic interpolation."},
{0, NULL, NULL, NULL}
{0, "NONE", 0, "None", "No interpolation."},
{1, "BILINEAR", 0, "Bilinear", "Bilinear interpolation."},
{2, "BICUBIC", 0, "Bicubic", "Bicubic interpolation."},
{0, NULL, 0, NULL, NULL}
};
static const EnumPropertyItem translation_unit_items[]= {
{0, "PIXELS", "Pixels", ""},
{1, "PERCENT", "Percent", ""},
{0, NULL, NULL, NULL}
{0, "PIXELS", 0, "Pixels", ""},
{1, "PERCENT", 0, "Percent", ""},
{0, NULL, 0, NULL, NULL}
};
srna = RNA_def_struct(brna, "TransformSequence", "EffectSequence");

22
source/blender/makesrna/intern/rna_sound.c
View File

@ -46,17 +46,17 @@ static void rna_def_sample(BlenderRNA *brna)
/* sound types */
static EnumPropertyItem prop_sample_type_items[] = {
{SAMPLE_INVALID, "INVALID", "Invalid", ""},
{SAMPLE_UNKNOWN, "UNKNOWN", "Unknown", ""},
{SAMPLE_RAW, "RAW", "Raw", ""},
{SAMPLE_WAV, "WAV", "WAV", "Uncompressed"},
{SAMPLE_MP2, "MP2", "MP2", "MPEG-1 Audio Layer 2"},
{SAMPLE_MP3, "MP3", "MP3", "MPEG-1 Audio Layer 3"},
{SAMPLE_OGG_VORBIS, "OGG_VORBIS", "Ogg Vorbis", ""},
{SAMPLE_WMA, "WMA", "WMA", "Windows Media Audio"},
{SAMPLE_ASF, "ASF", "ASF", "Windows Advanced Systems Format"},
{SAMPLE_AIFF, "AIFF", "AIFF", "Audio Interchange File Format"},
{0, NULL, NULL, NULL}};
{SAMPLE_INVALID, "INVALID", 0, "Invalid", ""},
{SAMPLE_UNKNOWN, "UNKNOWN", 0, "Unknown", ""},
{SAMPLE_RAW, "RAW", 0, "Raw", ""},
{SAMPLE_WAV, "WAV", 0, "WAV", "Uncompressed"},
{SAMPLE_MP2, "MP2", 0, "MP2", "MPEG-1 Audio Layer 2"},
{SAMPLE_MP3, "MP3", 0, "MP3", "MPEG-1 Audio Layer 3"},
{SAMPLE_OGG_VORBIS, "OGG_VORBIS", 0, "Ogg Vorbis", ""},
{SAMPLE_WMA, "WMA", 0, "WMA", "Windows Media Audio"},
{SAMPLE_ASF, "ASF", 0, "ASF", "Windows Advanced Systems Format"},
{SAMPLE_AIFF, "AIFF", 0, "AIFF", "Audio Interchange File Format"},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "SoundSample", "ID");
RNA_def_struct_sdna(srna, "bSample");

317
source/blender/makesrna/intern/rna_space.c
View File

@ -37,32 +37,50 @@
#include "WM_types.h"
EnumPropertyItem space_type_items[] = {
{SPACE_EMPTY, "EMPTY", "Empty", ""},
{SPACE_VIEW3D, "VIEW_3D", "3D View", ""},
{SPACE_IPO, "GRAPH_EDITOR", "Graph Editor", ""},
{SPACE_OUTLINER, "OUTLINER", "Outliner", ""},
{SPACE_BUTS, "BUTTONS_WINDOW", "Buttons Window", ""},
{SPACE_FILE, "FILE_BROWSER", "File Browser", ""},
{SPACE_IMAGE, "IMAGE_EDITOR", "Image Editor", ""},
{SPACE_INFO, "USER_PREFERENCES", "User Preferences", ""},
{SPACE_SEQ, "SEQUENCE_EDITOR", "Sequence Editor", ""},
{SPACE_TEXT, "TEXT_EDITOR", "Text Editor", ""},
//{SPACE_IMASEL, "IMAGE_BROWSER", "Image Browser", ""},
{SPACE_SOUND, "AUDIO_WINDOW", "Audio Window", ""},
{SPACE_ACTION, "DOPESHEET_EDITOR", "DopeSheet Editor", ""},
{SPACE_NLA, "NLA_EDITOR", "NLA Editor", ""},
{SPACE_SCRIPT, "SCRIPTS_WINDOW", "Scripts Window", ""},
{SPACE_TIME, "TIMELINE", "Timeline", ""},
{SPACE_NODE, "NODE_EDITOR", "Node Editor", ""},
{0, NULL, NULL, NULL}};
{SPACE_EMPTY, "EMPTY", 0, "Empty", ""},
{SPACE_VIEW3D, "VIEW_3D", 0, "3D View", ""},
{SPACE_IPO, "GRAPH_EDITOR", 0, "Graph Editor", ""},
{SPACE_OUTLINER, "OUTLINER", 0, "Outliner", ""},
{SPACE_BUTS, "BUTTONS_WINDOW", 0, "Buttons Window", ""},
{SPACE_FILE, "FILE_BROWSER", 0, "File Browser", ""},
{SPACE_IMAGE, "IMAGE_EDITOR", 0, "Image Editor", ""},
{SPACE_INFO, "USER_PREFERENCES", 0, "User Preferences", ""},
{SPACE_SEQ, "SEQUENCE_EDITOR", 0, "Sequence Editor", ""},
{SPACE_TEXT, "TEXT_EDITOR", 0, "Text Editor", ""},
//{SPACE_IMASEL, "IMAGE_BROWSER", 0, "Image Browser", ""},
{SPACE_SOUND, "AUDIO_WINDOW", 0, "Audio Window", ""},
{SPACE_ACTION, "DOPESHEET_EDITOR", 0, "DopeSheet Editor", ""},
{SPACE_NLA, "NLA_EDITOR", 0, "NLA Editor", ""},
{SPACE_SCRIPT, "SCRIPTS_WINDOW", 0, "Scripts Window", ""},
{SPACE_TIME, "TIMELINE", 0, "Timeline", ""},
{SPACE_NODE, "NODE_EDITOR", 0, "Node Editor", ""},
{0, NULL, 0, NULL, NULL}};
#define DC_RGB {0, "COLOR", ICON_IMAGE_RGB, "Color", "Draw image with RGB colors."}
#define DC_RGBA {SI_USE_ALPHA, "COLOR_ALPHA", ICON_IMAGE_RGB_ALPHA, "Color and Alpha", "Draw image with RGB colors and alpha transparency."}
#define DC_ALPHA {SI_SHOW_ALPHA, "ALPHA", ICON_IMAGE_ALPHA, "Alpha", "Draw alpha transparency channel."}
#define DC_Z {SI_SHOW_ZBUF, "Z_BUFFER", ICON_IMAGE_ZDEPTH, "Z-Buffer", "Draw Z-buffer associated with image (mapped from camera clip start to end)."}
#ifdef WITH_LCMS
#define DC_LCMS SI_COLOR_CORRECTION, "COLOR_CORRECTED", ICON_IMAGE_ALPHA, "Color Corrected", "Display color corrected image."}
#else
#define DC_LCMS {0, NULL, 0, NULL, NULL}
#endif
#define DC_ZERO {0, NULL, 0, NULL, NULL}
static EnumPropertyItem dc_all_items[] = {DC_RGB, DC_RGBA, DC_ALPHA, DC_Z, DC_LCMS, DC_ZERO};
#ifdef RNA_RUNTIME
#include "DNA_scene_types.h"
#include "DNA_screen_types.h"
#include "BKE_brush.h"
#include "BKE_context.h"
#include "ED_image.h"
#include "IMB_imbuf_types.h"
static StructRNA* rna_Space_refine(struct PointerRNA *ptr)
{
SpaceLink *space= (SpaceLink*)ptr->data;
@ -106,12 +124,14 @@ static StructRNA* rna_Space_refine(struct PointerRNA *ptr)
}
}
static PointerRNA rna_SpaceImage_uvedit_get(PointerRNA *ptr)
/* Space Image Editor */
static PointerRNA rna_SpaceImageEditor_uvedit_get(PointerRNA *ptr)
{
return rna_pointer_inherit_refine(ptr, &RNA_SpaceUVEditor, ptr->data);
}
static void rna_SpaceImage_paint_update(bContext *C, PointerRNA *ptr)
static void rna_SpaceImageEditor_paint_update(bContext *C, PointerRNA *ptr)
{
Scene *scene= CTX_data_scene(C);
@ -119,6 +139,58 @@ static void rna_SpaceImage_paint_update(bContext *C, PointerRNA *ptr)
brush_check_exists(&scene->toolsettings->imapaint.brush);
}
static int rna_SpaceImageEditor_show_render_get(PointerRNA *ptr)
{
SpaceImage *sima= (SpaceImage*)(ptr->data);
return ED_space_image_show_render(sima);
}
static int rna_SpaceImageEditor_show_paint_get(PointerRNA *ptr)
{
SpaceImage *sima= (SpaceImage*)(ptr->data);
return ED_space_image_show_paint(sima);
}
static int rna_SpaceImageEditor_show_uvedit_get(PointerRNA *ptr)
{
SpaceImage *sima= (SpaceImage*)(ptr->data);
bScreen *sc= (bScreen*)ptr->id.data;
return ED_space_image_show_uvedit(sima, sc->scene->obedit);
}
static void rna_SpaceImageEditor_image_set(PointerRNA *ptr, PointerRNA value)
{
SpaceImage *sima= (SpaceImage*)(ptr->data);
bScreen *sc= (bScreen*)ptr->id.data;
ED_space_image_set(NULL, sima, sc->scene, sc->scene->obedit, (Image*)value.data);
}
static EnumPropertyItem dc_rgb_items[] = {DC_RGB, DC_LCMS, DC_ZERO};
static EnumPropertyItem dc_alpha_items[] = {DC_RGB, DC_RGBA, DC_ALPHA, DC_LCMS, DC_ZERO};
static EnumPropertyItem dc_z_items[] = {DC_RGB, DC_Z, DC_LCMS, DC_ZERO};
static EnumPropertyItem *rna_SpaceImageEditor_draw_channels_itemf(PointerRNA *ptr)
{
SpaceImage *sima= (SpaceImage*)ptr->data;
ImBuf *ibuf= ED_space_image_buffer(sima);
int zbuf, alpha;
alpha= ibuf && (ibuf->channels == 4);
zbuf= ibuf && (ibuf->zbuf || ibuf->zbuf_float || (ibuf->channels==1));
if(alpha && zbuf)
return dc_all_items;
else if(alpha)
return dc_alpha_items;
else if(zbuf)
return dc_z_items;
else
return dc_rgb_items;
}
/* Space Text Editor */
void rna_SpaceTextEditor_word_wrap_set(PointerRNA *ptr, int value)
{
SpaceText *st= (SpaceText*)(ptr->data);
@ -135,6 +207,8 @@ void rna_SpaceTextEditor_text_set(PointerRNA *ptr, PointerRNA value)
st->top= 0;
}
/* Space Buttons */
StructRNA *rna_SpaceButtonsWindow_pin_id_typef(PointerRNA *ptr)
{
SpaceButs *sbuts= (SpaceButs*)(ptr->data);
@ -171,30 +245,30 @@ static void rna_def_space_image_uv(BlenderRNA *brna)
#if 0
static EnumPropertyItem select_mode_items[] = {
{SI_SELECT_VERTEX, "VERTEX", "Vertex", "Vertex selection mode."},
//{SI_SELECT_EDGE, "Edge", "Edge", "Edge selection mode."},
{SI_SELECT_FACE, "FACE", "Face", "Face selection mode."},
{SI_SELECT_ISLAND, "ISLAND", "Island", "Island selection mode."},
{0, NULL, NULL, NULL}};
{SI_SELECT_VERTEX, "VERTEX", 0, "Vertex", "Vertex selection mode."},
//{SI_SELECT_EDGE, "Edge", 0, "Edge", "Edge selection mode."},
{SI_SELECT_FACE, "FACE", 0, "Face", "Face selection mode."},
{SI_SELECT_ISLAND, "ISLAND", 0, "Island", "Island selection mode."},
{0, NULL, 0, NULL, NULL}};
#endif
static EnumPropertyItem sticky_mode_items[] = {
{SI_STICKY_DISABLE, "DISABLED", "Disabled", "Sticky vertex selection disabled."},
{SI_STICKY_LOC, "SHARED_LOCATION", "SHARED_LOCATION", "Select UVs that are at the same location and share a mesh vertex."},
{SI_STICKY_VERTEX, "SHARED_VERTEX", "SHARED_VERTEX", "Select UVs that share mesh vertex, irrespective if they are in the same location."},
{0, NULL, NULL, NULL}};
{SI_STICKY_DISABLE, "DISABLED", 0, "Disabled", "Sticky vertex selection disabled."},
{SI_STICKY_LOC, "SHARED_LOCATION", 0, "SHARED_LOCATION", "Select UVs that are at the same location and share a mesh vertex."},
{SI_STICKY_VERTEX, "SHARED_VERTEX", 0, "SHARED_VERTEX", "Select UVs that share mesh vertex, irrespective if they are in the same location."},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem dt_uv_items[] = {
{SI_UVDT_OUTLINE, "OUTLINE", "Outline", "Draw white edges with black outline."},
{SI_UVDT_DASH, "DASH", "Dash", "Draw dashed black-white edges."},
{SI_UVDT_BLACK, "BLACK", "Black", "Draw black edges."},
{SI_UVDT_WHITE, "WHITE", "White", "Draw white edges."},
{0, NULL, NULL, NULL}};
{SI_UVDT_OUTLINE, "OUTLINE", 0, "Outline", "Draw white edges with black outline."},
{SI_UVDT_DASH, "DASH", 0, "Dash", "Draw dashed black-white edges."},
{SI_UVDT_BLACK, "BLACK", 0, "Black", "Draw black edges."},
{SI_UVDT_WHITE, "WHITE", 0, "White", "Draw white edges."},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem dt_uvstretch_items[] = {
{SI_UVDT_STRETCH_ANGLE, "ANGLE", "Angle", "Angular distortion between UV and 3D angles."},
{SI_UVDT_STRETCH_AREA, "AREA", "Area", "Area distortion between UV and 3D faces."},
{0, NULL, NULL, NULL}};
{SI_UVDT_STRETCH_ANGLE, "ANGLE", 0, "Angle", "Angular distortion between UV and 3D angles."},
{SI_UVDT_STRETCH_AREA, "AREA", 0, "Area", "Area distortion between UV and 3D faces."},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "SpaceUVEditor", NULL);
RNA_def_struct_sdna(srna, "SpaceImage");
@ -211,45 +285,54 @@ static void rna_def_space_image_uv(BlenderRNA *brna)
RNA_def_property_enum_sdna(prop, NULL, "sticky");
RNA_def_property_enum_items(prop, sticky_mode_items);
RNA_def_property_ui_text(prop, "Sticky Selection Mode", "Automatically select also UVs sharing the same vertex as the ones being selected.");
RNA_def_property_update(prop, NC_IMAGE|ND_DISPLAY, NULL);
/* drawing */
prop= RNA_def_property(srna, "edge_draw_type", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "dt_uv");
RNA_def_property_enum_items(prop, dt_uv_items);
RNA_def_property_ui_text(prop, "Edge Draw Type", "Draw type for drawing UV edges.");
RNA_def_property_update(prop, NC_IMAGE|ND_DISPLAY, NULL);
prop= RNA_def_property(srna, "draw_smooth_edges", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", SI_SMOOTH_UV);
RNA_def_property_ui_text(prop, "Draw Smooth Edges", "Draw UV edges anti-aliased.");
RNA_def_property_update(prop, NC_IMAGE|ND_DISPLAY, NULL);
prop= RNA_def_property(srna, "draw_stretch", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", SI_DRAW_STRETCH);
RNA_def_property_ui_text(prop, "Draw Stretch", "Draw faces colored according to the difference in shape between UVs and their 3D coordinates (blue for low distortion, red for high distortion).");
RNA_def_property_update(prop, NC_IMAGE|ND_DISPLAY, NULL);
prop= RNA_def_property(srna, "draw_stretch_type", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "dt_uvstretch");
RNA_def_property_enum_items(prop, dt_uvstretch_items);
RNA_def_property_ui_text(prop, "Draw Stretch Type", "Type of stretch to draw.");
RNA_def_property_update(prop, NC_IMAGE|ND_DISPLAY, NULL);
prop= RNA_def_property(srna, "draw_modified_edges", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "dt_uvstretch");
RNA_def_property_enum_items(prop, dt_uvstretch_items);
RNA_def_property_ui_text(prop, "Draw Modified Edges", "Draw edges from the final mesh after object modifier evaluation.");
RNA_def_property_update(prop, NC_IMAGE|ND_DISPLAY, NULL);
/*prop= RNA_def_property(srna, "local_view", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", SI_LOCAL_UV);
RNA_def_property_ui_text(prop, "Local View", "Draw only faces with the currently displayed image assigned.");*/
RNA_def_property_ui_text(prop, "Local View", "Draw only faces with the currently displayed image assigned.");
RNA_def_property_update(prop, NC_IMAGE|ND_DISPLAY, NULL);*/
prop= RNA_def_property(srna, "normalized_coordinates", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", SI_COORDFLOATS);
RNA_def_property_ui_text(prop, "Normalized Coordinates", "Display UV coordinates from 0.0 to 1.0 rather than in pixels.");
RNA_def_property_update(prop, NC_IMAGE|ND_DISPLAY, NULL);
/* todo: move edge and face drawing options here from G.f */
/* editing */
/*prop= RNA_def_property(srna, "sync_selection", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", SI_SYNC_UVSEL);
RNA_def_property_ui_text(prop, "Sync Selection", "Keep UV and edit mode mesh selection in sync.");*/
RNA_def_property_ui_text(prop, "Sync Selection", "Keep UV and edit mode mesh selection in sync.");
RNA_def_property_update(prop, NC_IMAGE|ND_DISPLAY, NULL);*/
prop= RNA_def_property(srna, "snap_to_pixels", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", SI_PIXELSNAP);
@ -270,18 +353,18 @@ static void rna_def_space_outliner(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem display_mode_items[] = {
{0, "ALL_SCENES", "All Scenes", ""},
{1, "CURRENT_SCENE", "Current Scene", ""},
{2, "VISIBLE_LAYERS", "Visible Layers", ""},
{3, "SELECTED", "Selected", ""},
{4, "ACTIVE", "Active", ""},
{5, "SAME_TYPES", "Same Types", ""},
{6, "GROUPS", "Groups", ""},
{7, "LIBRARIES", "Libraries", ""},
{10, "SEQUENCE", "Sequence", ""},
{11, "DATABLOCKS", "Datablocks", ""},
{12, "USER_PREFERENCES", "User Preferences", ""},
{0, NULL, NULL, NULL}};
{0, "ALL_SCENES", 0, "All Scenes", ""},
{1, "CURRENT_SCENE", 0, "Current Scene", ""},
{2, "VISIBLE_LAYERS", 0, "Visible Layers", ""},
{3, "SELECTED", 0, "Selected", ""},
{4, "ACTIVE", 0, "Active", ""},
{5, "SAME_TYPES", 0, "Same Types", ""},
{6, "GROUPS", 0, "Groups", ""},
{7, "LIBRARIES", 0, "Libraries", ""},
{10, "SEQUENCE", 0, "Sequence", ""},
{11, "DATABLOCKS", 0, "Datablocks", ""},
{12, "USER_PREFERENCES", 0, "User Preferences", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "SpaceOutliner", "Space");
RNA_def_struct_sdna(srna, "SpaceOops");
@ -312,6 +395,7 @@ static void rna_def_background_image(BlenderRNA *brna)
prop= RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
RNA_def_property_pointer_sdna(prop, NULL, "ima");
RNA_def_property_ui_text(prop, "Image", "Image displayed and edited in this space.");
RNA_def_property_update(prop, NC_OBJECT|ND_GEOM_DATA, NULL);
prop= RNA_def_property(srna, "image_user", PROP_POINTER, PROP_NEVER_NULL);
RNA_def_property_pointer_sdna(prop, NULL, "iuser");
@ -343,28 +427,28 @@ static void rna_def_space_3dview(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem viewport_shading_items[] = {
{OB_BOUNDBOX, "BOUNDBOX", "Bounding Box", "Display the object's local bounding boxes only"},
{OB_WIRE, "WIREFRAME", "Wireframe", "Display the object as wire edges"},
{OB_SOLID, "SOLID", "Solid", "Display the object solid, lit with default OpenGL lights"},
{OB_SHADED, "SHADED", "Shaded", "Display the object solid, with preview shading interpolated at vertices"},
{OB_TEXTURE, "TEXTURED", "Textured", "Display the object solid, with face-assigned textures"},
{0, NULL, NULL, NULL}};
{OB_BOUNDBOX, "BOUNDBOX", 0, "Bounding Box", "Display the object's local bounding boxes only"},
{OB_WIRE, "WIREFRAME", 0, "Wireframe", "Display the object as wire edges"},
{OB_SOLID, "SOLID", 0, "Solid", "Display the object solid, lit with default OpenGL lights"},
{OB_SHADED, "SHADED", 0, "Shaded", "Display the object solid, with preview shading interpolated at vertices"},
{OB_TEXTURE, "TEXTURED", 0, "Textured", "Display the object solid, with face-assigned textures"},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem pivot_items[] = {
{V3D_CENTER, "BOUNDING_BOX_CENTER", "Bounding Box Center", ""},
{V3D_CURSOR, "CURSOR", "3D Cursor", ""},
{V3D_LOCAL, "INDIVIDUAL_CENTERS", "Individual Centers", ""},
{V3D_CENTROID, "MEDIAN_POINT", "Median Point", ""},
{V3D_ACTIVE, "ACTIVE_ELEMENT", "Active Element", ""},
{0, NULL, NULL, NULL}};
{V3D_CENTER, "BOUNDING_BOX_CENTER", 0, "Bounding Box Center", ""},
{V3D_CURSOR, "CURSOR", 0, "3D Cursor", ""},
{V3D_LOCAL, "INDIVIDUAL_CENTERS", 0, "Individual Centers", ""},
{V3D_CENTROID, "MEDIAN_POINT", 0, "Median Point", ""},
{V3D_ACTIVE, "ACTIVE_ELEMENT", 0, "Active Element", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem transform_orientation_items[] = {
{V3D_MANIP_GLOBAL, "ORIENT_GLOBAL", "Global", "Align the transformation axes to world space"},
{V3D_MANIP_LOCAL, "ORIENT_LOCAL", "Local", "Align the transformation axes to the selected objects' local space"},
{V3D_MANIP_NORMAL, "ORIENT_NORMAL", "Normal", "Align the transformation axes to average normal of selected elements (bone Y axis for pose mode)"},
{V3D_MANIP_VIEW, "ORIENT_VIEW", "View", "Align the transformation axes to the window"},
{V3D_MANIP_CUSTOM, "ORIENT_CUSTOM", "Custom", "Use a custom transform orientation"},
{0, NULL, NULL, NULL}};
{V3D_MANIP_GLOBAL, "ORIENT_GLOBAL", 0, "Global", "Align the transformation axes to world space"},
{V3D_MANIP_LOCAL, "ORIENT_LOCAL", 0, "Local", "Align the transformation axes to the selected objects' local space"},
{V3D_MANIP_NORMAL, "ORIENT_NORMAL", 0, "Normal", "Align the transformation axes to average normal of selected elements (bone Y axis for pose mode)"},
{V3D_MANIP_VIEW, "ORIENT_VIEW", 0, "View", "Align the transformation axes to the window"},
{V3D_MANIP_CUSTOM, "ORIENT_CUSTOM", 0, "Custom", "Use a custom transform orientation"},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "Space3DView", "Space");
RNA_def_struct_sdna(srna, "View3D");
@ -488,24 +572,24 @@ static void rna_def_space_buttons(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem buttons_context_items[] = {
{BCONTEXT_SCENE, "SCENE", "Scene", ""},
{BCONTEXT_WORLD, "WORLD", "World", ""},
{BCONTEXT_OBJECT, "OBJECT", "Object", ""},
{BCONTEXT_DATA, "DATA", "Data", ""},
{BCONTEXT_MATERIAL, "MATERIAL", "Material", ""},
{BCONTEXT_TEXTURE, "TEXTURE", "Texture", ""},
{BCONTEXT_PARTICLE, "PARTICLE", "Particle", ""},
{BCONTEXT_PHYSICS, "PHYSICS", "Physics", ""},
{BCONTEXT_GAME, "GAME", "Game", ""},
{BCONTEXT_BONE, "BONE", "Bone", ""},
{BCONTEXT_MODIFIER, "MODIFIER", "Modifier", ""},
{BCONTEXT_CONSTRAINT, "CONSTRAINT", "Constraint", ""},
{0, NULL, NULL, NULL}};
{BCONTEXT_SCENE, "SCENE", 0, "Scene", ""},
{BCONTEXT_WORLD, "WORLD", 0, "World", ""},
{BCONTEXT_OBJECT, "OBJECT", 0, "Object", ""},
{BCONTEXT_DATA, "DATA", 0, "Data", ""},
{BCONTEXT_MATERIAL, "MATERIAL", 0, "Material", ""},
{BCONTEXT_TEXTURE, "TEXTURE", 0, "Texture", ""},
{BCONTEXT_PARTICLE, "PARTICLE", 0, "Particle", ""},
{BCONTEXT_PHYSICS, "PHYSICS", 0, "Physics", ""},
{BCONTEXT_GAME, "GAME", 0, "Game", ""},
{BCONTEXT_BONE, "BONE", 0, "Bone", ""},
{BCONTEXT_MODIFIER, "MODIFIER", 0, "Modifier", ""},
{BCONTEXT_CONSTRAINT, "CONSTRAINT", 0, "Constraint", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem panel_alignment_items[] = {
{1, "HORIZONTAL", "Horizontal", ""},
{2, "VERTICAL", "Vertical", ""},
{0, NULL, NULL, NULL}};
{1, "HORIZONTAL", 0, "Horizontal", ""},
{2, "VERTICAL", 0, "Vertical", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "SpaceButtonsWindow", "Space");
RNA_def_struct_sdna(srna, "SpaceButs");
@ -534,55 +618,57 @@ static void rna_def_space_image(BlenderRNA *brna)
StructRNA *srna;
PropertyRNA *prop;
static EnumPropertyItem draw_channels_items[] = {
{0, "COLOR", "Color", "Draw image with RGB colors."},
{SI_USE_ALPHA, "COLOR_ALPHA", "Color and Alpha", "Draw image with RGB colors and alpha transparency."},
{SI_SHOW_ALPHA, "ALPHA", "Alpha", "Draw alpha transparency channel."},
{SI_SHOW_ZBUF, "Z_BUFFER", "Z-Buffer", "Draw Z-buffer associated with image (mapped from camera clip start to end)."},
{SI_COLOR_CORRECTION, "COLOR_CORRECTED", "Color Corrected", "Display color corrected image."},
{0, NULL, NULL, NULL}};
srna= RNA_def_struct(brna, "SpaceImageEditor", "Space");
RNA_def_struct_sdna(srna, "SpaceImage");
RNA_def_struct_ui_text(srna, "Space Image Editor", "Image and UV editor space data.");
/* image */
prop= RNA_def_property(srna, "image", PROP_POINTER, PROP_NONE);
RNA_def_property_pointer_funcs(prop, NULL, "rna_SpaceImageEditor_image_set", NULL);
RNA_def_property_ui_text(prop, "Image", "Image displayed and edited in this space.");
RNA_def_property_flag(prop, PROP_EDITABLE);
RNA_def_property_update(prop, NC_IMAGE|ND_DISPLAY, NULL);
prop= RNA_def_property(srna, "image_user", PROP_POINTER, PROP_NEVER_NULL);
RNA_def_property_pointer_sdna(prop, NULL, "iuser");
RNA_def_property_ui_text(prop, "Image User", "Parameters defining which layer, pass and frame of the image is displayed.");
RNA_def_property_update(prop, NC_IMAGE|ND_DISPLAY, NULL);
prop= RNA_def_property(srna, "curves", PROP_POINTER, PROP_NONE);
RNA_def_property_pointer_sdna(prop, NULL, "cumap");
RNA_def_property_ui_text(prop, "Curves", "Color curve mapping to use for displaying the image.");
RNA_def_property_update(prop, NC_IMAGE|ND_DISPLAY, NULL);
prop= RNA_def_property(srna, "image_pin", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "pin", 0);
RNA_def_property_ui_text(prop, "Image Pin", "Display current image regardless of object selection.");
RNA_def_property_update(prop, NC_IMAGE|ND_DISPLAY, NULL);
/* image draw */
prop= RNA_def_property(srna, "draw_repeated", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", SI_DRAW_TILE);
RNA_def_property_ui_text(prop, "Draw Repeated", "Draw the image repeated outside of the main view.");
RNA_def_property_update(prop, NC_IMAGE|ND_DISPLAY, NULL);
prop= RNA_def_property(srna, "draw_channels", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_bitflag_sdna(prop, NULL, "flag");
RNA_def_property_enum_items(prop, draw_channels_items);
RNA_def_property_enum_items(prop, dc_all_items);
RNA_def_property_enum_funcs(prop, NULL, NULL, "rna_SpaceImageEditor_draw_channels_itemf");
RNA_def_property_ui_text(prop, "Draw Channels", "Channels of the image to draw.");
RNA_def_property_update(prop, NC_IMAGE|ND_DISPLAY, NULL);
/* uv */
prop= RNA_def_property(srna, "uv_editor", PROP_POINTER, PROP_NEVER_NULL);
RNA_def_property_struct_type(prop, "SpaceUVEditor");
RNA_def_property_pointer_funcs(prop, "rna_SpaceImage_uvedit_get", NULL, NULL);
RNA_def_property_pointer_funcs(prop, "rna_SpaceImageEditor_uvedit_get", NULL, NULL);
RNA_def_property_ui_text(prop, "UV Editor", "UV editor settings.");
/* paint */
prop= RNA_def_property(srna, "image_painting", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "flag", SI_DRAWTOOL);
RNA_def_property_ui_text(prop, "Image Painting", "Enable image painting mode.");
RNA_def_property_update(prop, 0, "rna_SpaceImage_paint_update");
RNA_def_property_ui_icon(prop, ICON_TPAINT_HLT, 0);
RNA_def_property_update(prop, NC_IMAGE|ND_DISPLAY, "rna_SpaceImageEditor_paint_update");
/* grease pencil */
prop= RNA_def_property(srna, "grease_pencil", PROP_POINTER, PROP_NONE);
@ -597,24 +683,40 @@ static void rna_def_space_image(BlenderRNA *brna)
/* update */
prop= RNA_def_property(srna, "update_automatically", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "lock", 0);
RNA_def_property_ui_icon(prop, ICON_UNLOCKED, 1);
RNA_def_property_ui_text(prop, "Update Automatically", "Update other affected window spaces automatically to reflect changes during interactive operations such as transform.");
/* state */
prop= RNA_def_property(srna, "show_render", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(prop, "rna_SpaceImageEditor_show_render_get", NULL);
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_ui_text(prop, "Show Render", "Show render related properties.");
prop= RNA_def_property(srna, "show_paint", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(prop, "rna_SpaceImageEditor_show_paint_get", NULL);
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_ui_text(prop, "Show Paint", "Show paint related properties.");
prop= RNA_def_property(srna, "show_uvedit", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_funcs(prop, "rna_SpaceImageEditor_show_uvedit_get", NULL);
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_ui_text(prop, "Show UV Editor", "Show uv editing related properties.");
rna_def_space_image_uv(brna);
}
static void rna_def_space_sequencer(BlenderRNA *brna)
{
StructRNA *srna;
PropertyRNA *prop;
static EnumPropertyItem display_mode_items[] = {
{SEQ_DRAW_SEQUENCE, "SEQUENCER", "Sequencer", ""},
{SEQ_DRAW_IMG_IMBUF, "IMAGE", "Image Preview", ""},
{SEQ_DRAW_IMG_WAVEFORM, "WAVEFORM", "Luma Waveform", ""},
{SEQ_DRAW_IMG_VECTORSCOPE, "VECTOR_SCOPE", "Chroma Vectorscope", ""},
{SEQ_DRAW_IMG_HISTOGRAM, "HISTOGRAM", "Histogram", ""},
{0, NULL, NULL, NULL}};
{SEQ_DRAW_SEQUENCE, "SEQUENCER", 0, "Sequencer", ""},
{SEQ_DRAW_IMG_IMBUF, "IMAGE", 0, "Image Preview", ""},
{SEQ_DRAW_IMG_WAVEFORM, "WAVEFORM", 0, "Luma Waveform", ""},
{SEQ_DRAW_IMG_VECTORSCOPE, "VECTOR_SCOPE", 0, "Chroma Vectorscope", ""},
{SEQ_DRAW_IMG_HISTOGRAM, "HISTOGRAM", 0, "Histogram", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "SpaceSequenceEditor", "Space");
RNA_def_struct_sdna(srna, "SpaceSeq");
@ -691,9 +793,9 @@ static void rna_def_space_text(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem font_size_items[] = {
{12, "SCREEN_12", "Screen 12", ""},
{15, "SCREEN_15", "Screen 15", ""},
{0, NULL, NULL, NULL}};
{12, "SCREEN_12", 0, "Screen 12", ""},
{15, "SCREEN_15", 0, "Screen 15", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "SpaceTextEditor", "Space");
RNA_def_struct_sdna(srna, "SpaceText");
@ -710,17 +812,20 @@ static void rna_def_space_text(BlenderRNA *brna)
prop= RNA_def_property(srna, "syntax_highlight", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "showsyntax", 0);
RNA_def_property_ui_text(prop, "Syntax Highlight", "Syntax highlight for scripting.");
RNA_def_property_ui_icon(prop, ICON_SYNTAX_OFF, 1);
RNA_def_property_update(prop, NC_TEXT|ND_DISPLAY, NULL);
prop= RNA_def_property(srna, "word_wrap", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "wordwrap", 0);
RNA_def_property_boolean_funcs(prop, NULL, "rna_SpaceTextEditor_word_wrap_set");
RNA_def_property_ui_text(prop, "Word Wrap", "Wrap words if there is not enough horizontal space.");
RNA_def_property_ui_icon(prop, ICON_WORDWRAP_OFF, 1);
RNA_def_property_update(prop, NC_TEXT|ND_DISPLAY, NULL);
prop= RNA_def_property(srna, "line_numbers", PROP_BOOLEAN, PROP_NONE);
RNA_def_property_boolean_sdna(prop, NULL, "showlinenrs", 0);
RNA_def_property_ui_text(prop, "Line Numbers", "Show line numbers next to the text.");
RNA_def_property_ui_icon(prop, ICON_LINENUMBERS_OFF, 1);
RNA_def_property_update(prop, NC_TEXT|ND_DISPLAY, NULL);
prop= RNA_def_property(srna, "overwrite", PROP_BOOLEAN, PROP_NONE);

228
source/blender/makesrna/intern/rna_texture.c
View File

@ -127,12 +127,12 @@ static void rna_def_color_ramp(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_interpolation_items[] = {
{1, "EASE", "Ease", ""},
{3, "CARDINAL", "Cardinal", ""},
{0, "LINEAR", "Linear", ""},
{2, "B_SPLINE", "B-Spline", ""},
{4, "CONSTANT", "Constant", ""},
{0, NULL, NULL, NULL}};
{1, "EASE", 0, "Ease", ""},
{3, "CARDINAL", 0, "Cardinal", ""},
{0, "LINEAR", 0, "Linear", ""},
{2, "B_SPLINE", 0, "B-Spline", ""},
{4, "CONSTANT", 0, "Constant", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "ColorRamp", NULL);
RNA_def_struct_sdna(srna, "ColorBand");
@ -201,21 +201,21 @@ static void rna_def_mtex(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_blend_type_items[] = {
{MTEX_BLEND, "MIX", "Mix", ""},
{MTEX_ADD, "ADD", "Add", ""},
{MTEX_SUB, "SUBTRACT", "Subtract", ""},
{MTEX_MUL, "MULTIPLY", "Multiply", ""},
{MTEX_SCREEN, "SCREEN", "Screen", ""},
{MTEX_OVERLAY, "OVERLAY", "Overlay", ""},
{MTEX_DIFF, "DIFFERENCE", "Difference", ""},
{MTEX_DIV, "DIVIDE", "Divide", ""},
{MTEX_DARK, "DARKEN", "Darken", ""},
{MTEX_LIGHT, "LIGHTEN", "Lighten", ""},
{MTEX_BLEND_HUE, "HUE", "Hue", ""},
{MTEX_BLEND_SAT, "SATURATION", "Saturation", ""},
{MTEX_BLEND_VAL, "VALUE", "Value", ""},
{MTEX_BLEND_COLOR, "COLOR", "Color", ""},
{0, NULL, NULL, NULL}};
{MTEX_BLEND, "MIX", 0, "Mix", ""},
{MTEX_ADD, "ADD", 0, "Add", ""},
{MTEX_SUB, "SUBTRACT", 0, "Subtract", ""},
{MTEX_MUL, "MULTIPLY", 0, "Multiply", ""},
{MTEX_SCREEN, "SCREEN", 0, "Screen", ""},
{MTEX_OVERLAY, "OVERLAY", 0, "Overlay", ""},
{MTEX_DIFF, "DIFFERENCE", 0, "Difference", ""},
{MTEX_DIV, "DIVIDE", 0, "Divide", ""},
{MTEX_DARK, "DARKEN", 0, "Darken", ""},
{MTEX_LIGHT, "LIGHTEN", 0, "Lighten", ""},
{MTEX_BLEND_HUE, "HUE", 0, "Hue", ""},
{MTEX_BLEND_SAT, "SATURATION", 0, "Saturation", ""},
{MTEX_BLEND_VAL, "VALUE", 0, "Value", ""},
{MTEX_BLEND_COLOR, "COLOR", 0, "Color", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "TextureSlot", NULL);
RNA_def_struct_sdna(srna, "MTex");
@ -323,10 +323,10 @@ static void rna_def_environment_map_common(StructRNA *srna)
PropertyRNA *prop;
static EnumPropertyItem prop_source_items[] = {
{ENV_STATIC, "STATIC", "Static", "Calculates environment map only once"},
{ENV_ANIM, "ANIMATED", "Animated", "Calculates environment map at each rendering"},
{ENV_LOAD, "LOADED", "Loaded", "Loads saved environment map from disk"},
{0, NULL, NULL, NULL}};
{ENV_STATIC, "STATIC", 0, "Static", "Calculates environment map only once"},
{ENV_ANIM, "ANIMATED", 0, "Animated", "Calculates environment map at each rendering"},
{ENV_LOAD, "LOADED", 0, "Loaded", "Loads saved environment map from disk"},
{0, NULL, 0, NULL, NULL}};
prop= RNA_def_property(srna, "source", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "stype");
@ -348,9 +348,9 @@ static void rna_def_environment_map(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_type_items[] = {
{ENV_CUBE, "CUBE", "Cube", "Use environment map with six cube sides."},
{ENV_PLANE, "PLANE", "Plane", "Only one side is rendered, with Z axis pointing in direction of image."},
{0, NULL, NULL, NULL}};
{ENV_CUBE, "CUBE", 0, "Cube", "Use environment map with six cube sides."},
{ENV_PLANE, "PLANE", 0, "Plane", "Only one side is rendered, with Z axis pointing in direction of image."},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "EnvironmentMap", NULL);
RNA_def_struct_sdna(srna, "EnvMap");
@ -400,22 +400,22 @@ static void rna_def_environment_map(BlenderRNA *brna)
}
static EnumPropertyItem prop_noise_basis_items[] = {
{TEX_BLENDER, "BLENDER_ORIGINAL", "Blender Original", ""},
{TEX_STDPERLIN, "ORIGINAL_PERLIN", "Original Perlin", ""},
{TEX_NEWPERLIN, "IMPROVED_PERLIN", "Improved Perlin", ""},
{TEX_VORONOI_F1, "VORONOI_F1", "Voronoi F1", ""},
{TEX_VORONOI_F2, "VORONOI_F2", "Voronoi F2", ""},
{TEX_VORONOI_F3, "VORONOI_F3", "Voronoi F3", ""},
{TEX_VORONOI_F4, "VORONOI_F4", "Voronoi F4", ""},
{TEX_VORONOI_F2F1, "VORONOI_F2_F1", "Voronoi F2-F1", ""},
{TEX_VORONOI_CRACKLE, "VORONOI_CRACKLE", "Voronoi Crackle", ""},
{TEX_CELLNOISE, "CELL_NOISE", "Cell Noise", ""},
{0, NULL, NULL, NULL}};
{TEX_BLENDER, "BLENDER_ORIGINAL", 0, "Blender Original", ""},
{TEX_STDPERLIN, "ORIGINAL_PERLIN", 0, "Original Perlin", ""},
{TEX_NEWPERLIN, "IMPROVED_PERLIN", 0, "Improved Perlin", ""},
{TEX_VORONOI_F1, "VORONOI_F1", 0, "Voronoi F1", ""},
{TEX_VORONOI_F2, "VORONOI_F2", 0, "Voronoi F2", ""},
{TEX_VORONOI_F3, "VORONOI_F3", 0, "Voronoi F3", ""},
{TEX_VORONOI_F4, "VORONOI_F4", 0, "Voronoi F4", ""},
{TEX_VORONOI_F2F1, "VORONOI_F2_F1", 0, "Voronoi F2-F1", ""},
{TEX_VORONOI_CRACKLE, "VORONOI_CRACKLE", 0, "Voronoi Crackle", ""},
{TEX_CELLNOISE, "CELL_NOISE", 0, "Cell Noise", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem prop_noise_type[] = {
{TEX_NOISESOFT, "SOFT_NOISE", "Soft", ""},
{TEX_NOISEPERL, "HARD_NOISE", "Hard", ""},
{0, NULL, NULL, NULL}};
{TEX_NOISESOFT, "SOFT_NOISE", 0, "Soft", ""},
{TEX_NOISEPERL, "HARD_NOISE", 0, "Hard", ""},
{0, NULL, 0, NULL, NULL}};
static void rna_def_texture_clouds(BlenderRNA *brna)
@ -424,9 +424,9 @@ static void rna_def_texture_clouds(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_clouds_stype[] = {
{TEX_DEFAULT, "GREYSCALE", "Greyscale", ""},
{TEX_COLOR, "COLOR", "Color", ""},
{0, NULL, NULL, NULL}};
{TEX_DEFAULT, "GREYSCALE", 0, "Greyscale", ""},
{TEX_COLOR, "COLOR", 0, "Color", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "CloudsTexture", "Texture");
RNA_def_struct_ui_text(srna, "Clouds Texture", "Procedural noise texture.");
@ -477,17 +477,17 @@ static void rna_def_texture_wood(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_wood_stype[] = {
{TEX_BAND, "BANDS", "Bands", "Uses standard wood texture in bands"},
{TEX_RING, "RINGS", "Rings", "Uses wood texture in rings"},
{TEX_BANDNOISE, "BANDNOISE", "Band Noise", "Adds noise to standard wood"},
{TEX_RINGNOISE, "RINGNOISE", "Ring Noise", "Adds noise to rings"},
{0, NULL, NULL, NULL}};
{TEX_BAND, "BANDS", 0, "Bands", "Uses standard wood texture in bands"},
{TEX_RING, "RINGS", 0, "Rings", "Uses wood texture in rings"},
{TEX_BANDNOISE, "BANDNOISE", 0, "Band Noise", "Adds noise to standard wood"},
{TEX_RINGNOISE, "RINGNOISE", 0, "Ring Noise", "Adds noise to rings"},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem prop_wood_noisebasis2[] = {
{TEX_SIN, "SIN", "Sine", "Uses a sine wave to produce bands"},
{TEX_SAW, "SAW", "Saw", "Uses a saw wave to produce bands"},
{TEX_TRI, "TRI", "Tri", "Uses a triangle wave to produce bands"},
{0, NULL, NULL, NULL}};
{TEX_SIN, "SIN", 0, "Sine", "Uses a sine wave to produce bands"},
{TEX_SAW, "SAW", 0, "Saw", "Uses a saw wave to produce bands"},
{TEX_TRI, "TRI", 0, "Tri", "Uses a triangle wave to produce bands"},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "WoodTexture", "Texture");
RNA_def_struct_ui_text(srna, "Wood Texture", "Procedural noise texture.");
@ -545,16 +545,16 @@ static void rna_def_texture_marble(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_marble_stype[] = {
{TEX_SOFT, "SOFT", "Soft", "Uses soft marble"},
{TEX_SHARP, "SHARP", "Sharp", "Uses more clearly defined marble"},
{TEX_SHARPER, "SHARPER", "Sharper", "Uses very clearly defined marble"},
{0, NULL, NULL, NULL}};
{TEX_SOFT, "SOFT", 0, "Soft", "Uses soft marble"},
{TEX_SHARP, "SHARP", 0, "Sharp", "Uses more clearly defined marble"},
{TEX_SHARPER, "SHARPER", 0, "Sharper", "Uses very clearly defined marble"},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem prop_marble_noisebasis2[] = {
{TEX_SIN, "SIN", "Sin", "Uses a sine wave to produce bands"},
{TEX_SAW, "SAW", "Saw", "Uses a saw wave to produce bands"},
{TEX_TRI, "TRI", "Tri", "Uses a triangle wave to produce bands"},
{0, NULL, NULL, NULL}};
{TEX_SIN, "SIN", 0, "Sin", "Uses a sine wave to produce bands"},
{TEX_SAW, "SAW", 0, "Saw", "Uses a saw wave to produce bands"},
{TEX_TRI, "TRI", 0, "Tri", "Uses a triangle wave to produce bands"},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "MarbleTexture", "Texture");
RNA_def_struct_ui_text(srna, "Marble Texture", "Procedural noise texture.");
@ -643,14 +643,14 @@ static void rna_def_texture_blend(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_blend_progression[] = {
{TEX_LIN, "LINEAR", "Linear", "Creates a linear progression"},
{TEX_QUAD, "QUADRATIC", "Quadratic", "Creates a quadratic progression"},
{TEX_EASE, "EASING", "Easing", "Creates a progression easing from one step to the next"},
{TEX_DIAG, "DIAGONAL", "Diagonal", "Creates a diagonal progression"},
{TEX_SPHERE, "SPHERICAL", "Spherical", "Creates a spherical progression"},
{TEX_HALO, "QUADRATIC_SPHERE", "Quadratic sphere", "Creates a quadratic progression in the shape of a sphere"},
{TEX_RAD, "RADIAL", "Radial", "Creates a radial progression"},
{0, NULL, NULL, NULL}};
{TEX_LIN, "LINEAR", 0, "Linear", "Creates a linear progression"},
{TEX_QUAD, "QUADRATIC", 0, "Quadratic", "Creates a quadratic progression"},
{TEX_EASE, "EASING", 0, "Easing", "Creates a progression easing from one step to the next"},
{TEX_DIAG, "DIAGONAL", 0, "Diagonal", "Creates a diagonal progression"},
{TEX_SPHERE, "SPHERICAL", 0, "Spherical", "Creates a spherical progression"},
{TEX_HALO, "QUADRATIC_SPHERE", 0, "Quadratic sphere", "Creates a quadratic progression in the shape of a sphere"},
{TEX_RAD, "RADIAL", 0, "Radial", "Creates a radial progression"},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "BlendTexture", "Texture");
RNA_def_struct_ui_text(srna, "Blend Texture", "Procedural color blending texture.");
@ -674,10 +674,10 @@ static void rna_def_texture_stucci(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_stucci_stype[] = {
{TEX_PLASTIC, "PLASTIC", "Plastic", "Uses standard stucci"},
{TEX_WALLIN, "WALL_IN", "Wall in", "Creates Dimples"},
{TEX_WALLOUT, "WALL_OUT", "Wall out", "Creates Ridges"},
{0, NULL, NULL, NULL}};
{TEX_PLASTIC, "PLASTIC", 0, "Plastic", "Uses standard stucci"},
{TEX_WALLIN, "WALL_IN", 0, "Wall in", "Creates Dimples"},
{TEX_WALLOUT, "WALL_OUT", 0, "Wall out", "Creates Ridges"},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "StucciTexture", "Texture");
RNA_def_struct_ui_text(srna, "Stucci Texture", "Procedural noise texture.");
@ -731,12 +731,12 @@ static void rna_def_texture_image(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_image_extension[] = {
{1, "EXTEND", "Extend", "Extends by repeating edge pixels of the image"},
{2, "CLIP", "Clip", "Clips to image size and sets exterior pixels as transparent"},
{4, "CLIP_CUBE", "Clip Cube", "Clips to cubic-shaped area around the image and sets exterior pixels as transparent"},
{3, "REPEAT", "Repeat", "Causes the image to repeat horizontally and vertically"},
{5, "CHECKER", "Checker", "Causes the image to repeat in checker board pattern"},
{0, NULL, NULL, NULL}};
{1, "EXTEND", 0, "Extend", "Extends by repeating edge pixels of the image"},
{2, "CLIP", 0, "Clip", "Clips to image size and sets exterior pixels as transparent"},
{4, "CLIP_CUBE", 0, "Clip Cube", "Clips to cubic-shaped area around the image and sets exterior pixels as transparent"},
{3, "REPEAT", 0, "Repeat", "Causes the image to repeat horizontally and vertically"},
{5, "CHECKER", 0, "Checker", "Causes the image to repeat in checker board pattern"},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "ImageTexture", "Texture");
RNA_def_struct_ui_text(srna, "Image Texture", "");
@ -920,12 +920,12 @@ static void rna_def_texture_musgrave(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_musgrave_type[] = {
{TEX_MFRACTAL, "MULTIFRACTAL", "Multifractal", ""},
{TEX_RIDGEDMF, "RIDGED_MULTIFRACTAL", "Ridged Multifractal", ""},
{TEX_HYBRIDMF, "HYBRID_MULTIFRACTAL", "Hybrid Multifractal", ""},
{TEX_FBM, "FBM", "fBM", ""},
{TEX_HTERRAIN, "HETERO_TERRAIN", "Hetero Terrain", ""},
{0, NULL, NULL, NULL}};
{TEX_MFRACTAL, "MULTIFRACTAL", 0, "Multifractal", ""},
{TEX_RIDGEDMF, "RIDGED_MULTIFRACTAL", 0, "Ridged Multifractal", ""},
{TEX_HYBRIDMF, "HYBRID_MULTIFRACTAL", 0, "Hybrid Multifractal", ""},
{TEX_FBM, "FBM", 0, "fBM", ""},
{TEX_HTERRAIN, "HETERO_TERRAIN", 0, "Hetero Terrain", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "MusgraveTexture", "Texture");
RNA_def_struct_ui_text(srna, "Musgrave", "Procedural musgrave texture.");
@ -999,22 +999,22 @@ static void rna_def_texture_voronoi(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_distance_metric_items[] = {
{TEX_DISTANCE, "DISTANCE", "Actual Distance", ""},
{TEX_DISTANCE_SQUARED, "DISTANCE_SQUARED", "Distance Squared", ""},
{TEX_MANHATTAN, "MANHATTAN", "Manhattan", ""},
{TEX_CHEBYCHEV, "CHEBYCHEV", "Chebychev", ""},
{TEX_MINKOVSKY_HALF, "MINKOVSKY_HALF", "Minkovsky 1/2", ""},
{TEX_MINKOVSKY_FOUR, "MINKOVSKY_FOUR", "Minkovsky 4", ""},
{TEX_MINKOVSKY, "MINKOVSKY", "Minkovsky", ""},
{0, NULL, NULL, NULL}};
{TEX_DISTANCE, "DISTANCE", 0, "Actual Distance", ""},
{TEX_DISTANCE_SQUARED, "DISTANCE_SQUARED", 0, "Distance Squared", ""},
{TEX_MANHATTAN, "MANHATTAN", 0, "Manhattan", ""},
{TEX_CHEBYCHEV, "CHEBYCHEV", 0, "Chebychev", ""},
{TEX_MINKOVSKY_HALF, "MINKOVSKY_HALF", 0, "Minkovsky 1/2", ""},
{TEX_MINKOVSKY_FOUR, "MINKOVSKY_FOUR", 0, "Minkovsky 4", ""},
{TEX_MINKOVSKY, "MINKOVSKY", 0, "Minkovsky", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem prop_coloring_items[] = {
/* XXX: OK names / descriptions? */
{TEX_INTENSITY, "INTENSITY", "Intensity", "Only calculate intensity."},
{TEX_COL1, "POSITION", "Position", "Color cells by position."},
{TEX_COL2, "POSITION_OUTLINE", "Position and Outline", "Use position plus an outline based on F2-F.1"},
{TEX_COL3, "POSITION_OUTLINE_INTENSITY", "Position, Outline, and Intensity", "Multiply position and outline by intensity."},
{0, NULL, NULL, NULL}};
{TEX_INTENSITY, "INTENSITY", 0, "Intensity", "Only calculate intensity."},
{TEX_COL1, "POSITION", 0, "Position", "Color cells by position."},
{TEX_COL2, "POSITION_OUTLINE", 0, "Position and Outline", "Use position plus an outline based on F2-F.1"},
{TEX_COL3, "POSITION_OUTLINE_INTENSITY", 0, "Position, Outline, and Intensity", "Multiply position and outline by intensity."},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "VoronoiTexture", "Texture");
RNA_def_struct_ui_text(srna, "Voronoi", "Procedural voronoi texture.");
@ -1112,21 +1112,21 @@ static void rna_def_texture(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem prop_type_items[] = {
{0, "NONE", "None", ""},
{TEX_CLOUDS, "CLOUDS", "Clouds", ""},
{TEX_WOOD, "WOOD", "Wood", ""},
{TEX_MARBLE, "MARBLE", "Marble", ""},
{TEX_MAGIC, "MAGIC", "Magic", ""},
{TEX_BLEND, "BLEND", "Blend", ""},
{TEX_STUCCI, "STUCCI", "Stucci", ""},
{TEX_NOISE, "NOISE", "Noise", ""},
{TEX_IMAGE, "IMAGE", "Image/Movie", ""},
{TEX_PLUGIN, "PLUGIN", "Plugin", ""},
{TEX_ENVMAP, "ENVIRONMENT_MAP", "Environment Map", ""},
{TEX_MUSGRAVE, "MUSGRAVE", "Musgrave", ""},
{TEX_VORONOI, "VORONOI", "Voronoi", ""},
{TEX_DISTNOISE, "DISTORTED_NOISE", "Distorted Noise", ""},
{0, NULL, NULL, NULL}};
{0, "NONE", 0, "None", ""},
{TEX_CLOUDS, "CLOUDS", 0, "Clouds", ""},
{TEX_WOOD, "WOOD", 0, "Wood", ""},
{TEX_MARBLE, "MARBLE", 0, "Marble", ""},
{TEX_MAGIC, "MAGIC", 0, "Magic", ""},
{TEX_BLEND, "BLEND", 0, "Blend", ""},
{TEX_STUCCI, "STUCCI", 0, "Stucci", ""},
{TEX_NOISE, "NOISE", 0, "Noise", ""},
{TEX_IMAGE, "IMAGE", 0, "Image/Movie", ""},
{TEX_PLUGIN, "PLUGIN", 0, "Plugin", ""},
{TEX_ENVMAP, "ENVIRONMENT_MAP", 0, "Environment Map", ""},
{TEX_MUSGRAVE, "MUSGRAVE", 0, "Musgrave", ""},
{TEX_VORONOI, "VORONOI", 0, "Voronoi", ""},
{TEX_DISTNOISE, "DISTORTED_NOISE", 0, "Distorted Noise", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "Texture", "ID");
RNA_def_struct_sdna(srna, "Tex");

32
source/blender/makesrna/intern/rna_ui.c
View File

@ -24,6 +24,8 @@
#include <stdlib.h>
#include "DNA_screen_types.h"
#include "RNA_define.h"
#include "RNA_types.h"
@ -40,8 +42,6 @@
#include "RNA_access.h"
#include "DNA_screen_types.h"
#include "BLI_dynstr.h"
#include "BKE_context.h"
@ -497,23 +497,23 @@ static void rna_def_ui_layout(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem alignment_items[] = {
{UI_LAYOUT_ALIGN_EXPAND, "EXPAND", "Expand", ""},
{UI_LAYOUT_ALIGN_LEFT, "LEFT", "Left", ""},
{UI_LAYOUT_ALIGN_CENTER, "CENTER", "Center", ""},
{UI_LAYOUT_ALIGN_RIGHT, "RIGHT", "RIght", ""},
{0, NULL, NULL, NULL}};
{UI_LAYOUT_ALIGN_EXPAND, "EXPAND", 0, "Expand", ""},
{UI_LAYOUT_ALIGN_LEFT, "LEFT", 0, "Left", ""},
{UI_LAYOUT_ALIGN_CENTER, "CENTER", 0, "Center", ""},
{UI_LAYOUT_ALIGN_RIGHT, "RIGHT", 0, "RIght", ""},
{0, NULL, 0, NULL, NULL}};
/* see WM_types.h */
static EnumPropertyItem operator_context_items[] = {
{WM_OP_INVOKE_DEFAULT, "INVOKE_DEFAULT", "Invoke Default", ""},
{WM_OP_INVOKE_REGION_WIN, "INVOKE_REGION_WIN", "Invoke Region Window", ""},
{WM_OP_INVOKE_AREA, "INVOKE_AREA", "Invoke Area", ""},
{WM_OP_INVOKE_SCREEN, "INVOKE_SCREEN", "Invoke Screen", ""},
{WM_OP_EXEC_DEFAULT, "EXEC_DEFAULT", "Exec Default", ""},
{WM_OP_EXEC_REGION_WIN, "EXEC_REGION_WIN", "Exec Region Window", ""},
{WM_OP_EXEC_AREA, "EXEC_AREA", "Exec Area", ""},
{WM_OP_EXEC_SCREEN, "EXEC_SCREEN", "Exec Screen", ""},
{0, NULL, NULL, NULL}};
{WM_OP_INVOKE_DEFAULT, "INVOKE_DEFAULT", 0, "Invoke Default", ""},
{WM_OP_INVOKE_REGION_WIN, "INVOKE_REGION_WIN", 0, "Invoke Region Window", ""},
{WM_OP_INVOKE_AREA, "INVOKE_AREA", 0, "Invoke Area", ""},
{WM_OP_INVOKE_SCREEN, "INVOKE_SCREEN", 0, "Invoke Screen", ""},
{WM_OP_EXEC_DEFAULT, "EXEC_DEFAULT", 0, "Exec Default", ""},
{WM_OP_EXEC_REGION_WIN, "EXEC_REGION_WIN", 0, "Exec Region Window", ""},
{WM_OP_EXEC_AREA, "EXEC_AREA", 0, "Exec Area", ""},
{WM_OP_EXEC_SCREEN, "EXEC_SCREEN", 0, "Exec Screen", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "UILayout", NULL);
RNA_def_struct_sdna(srna, "uiLayout");

128
source/blender/makesrna/intern/rna_userdef.c
View File

@ -1396,15 +1396,15 @@ static void rna_def_userdef_view(BlenderRNA *brna)
StructRNA *srna;
static EnumPropertyItem view_zoom_styles[] = {
{USER_ZOOM_CONT, "CONTINUE", "Continue", "Old style zoom, continues while moving mouse up or down."},
{USER_ZOOM_DOLLY, "DOLLY", "Dolly", "Zooms in and out based on vertical mouse movement."},
{USER_ZOOM_SCALE, "SCALE", "Scale", "Zooms in and out like scaling the view, mouse movements relative to center."},
{0, NULL, NULL, NULL}};
{USER_ZOOM_CONT, "CONTINUE", 0, "Continue", "Old style zoom, continues while moving mouse up or down."},
{USER_ZOOM_DOLLY, "DOLLY", 0, "Dolly", "Zooms in and out based on vertical mouse movement."},
{USER_ZOOM_SCALE, "SCALE", 0, "Scale", "Zooms in and out like scaling the view, mouse movements relative to center."},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem view_rotation_items[] = {
{0, "TURNTABLE", "Turntable", "Use turntable style rotation in the viewport."},
{USER_TRACKBALL, "TRACKBALL", "Trackball", "Use trackball style rotation in the viewport."},
{0, NULL, NULL, NULL}};
{0, "TURNTABLE", 0, "Turntable", "Use turntable style rotation in the viewport."},
{USER_TRACKBALL, "TRACKBALL", 0, "Trackball", "Use trackball style rotation in the viewport."},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "UserPreferencesView", NULL);
@ -1627,15 +1627,15 @@ static void rna_def_userdef_edit(BlenderRNA *brna)
StructRNA *srna;
static EnumPropertyItem auto_key_modes[] = {
{AUTOKEY_MODE_NORMAL, "ADD_REPLACE_KEYS", "Add/Replace Keys", ""},
{AUTOKEY_MODE_EDITKEYS, "REPLACE_KEYS", "Replace Keys", ""},
{0, NULL, NULL, NULL}};
{AUTOKEY_MODE_NORMAL, "ADD_REPLACE_KEYS", 0, "Add/Replace Keys", ""},
{AUTOKEY_MODE_EDITKEYS, "REPLACE_KEYS", 0, "Replace Keys", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem new_interpolation_types[] = {
{BEZT_IPO_CONST, "CONSTANT", "Constant", ""},
{BEZT_IPO_LIN, "LINEAR", "Linear", ""},
{BEZT_IPO_BEZ, "BEZIER", "Bezier", ""},
{0, NULL, NULL, NULL}};
{BEZT_IPO_CONST, "CONSTANT", 0, "Constant", ""},
{BEZT_IPO_LIN, "LINEAR", 0, "Linear", ""},
{BEZT_IPO_BEZ, "BEZIER", 0, "Bezier", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "UserPreferencesEdit", NULL);
RNA_def_struct_sdna(srna, "UserDef");
@ -1780,30 +1780,30 @@ static void rna_def_userdef_language(BlenderRNA *brna)
/* hardcoded here, could become dynamic somehow */
static EnumPropertyItem language_items[] = {
{0, "ENGLISH", "English", ""},
{1, "JAPANESE", "Japanese", ""},
{2, "DUTCH", "Dutch", ""},
{3, "ITALIAN", "Italian", ""},
{4, "GERMAN", "German", ""},
{5, "FINNISH", "Finnish", ""},
{6, "SWEDISH", "Swedish", ""},
{7, "FRENCH", "French", ""},
{8, "SPANISH", "Spanish", ""},
{9, "CATALAN", "Catalan", ""},
{10, "CZECH", "Czech", ""},
{11, "BRAZILIAN_PORTUGUESE", "Brazilian Portuguese", ""},
{12, "SIMPLIFIED_CHINESE", "Simplified Chinese", ""},
{13, "RUSSIAN", "Russian", ""},
{14, "CROATIAN", "Croatian", ""},
{15, "SERBIAN", "Serbian", ""},
{16, "UKRAINIAN", "Ukrainian", ""},
{17, "POLISH", "Polish", ""},
{18, "ROMANIAN", "Romanian", ""},
{19, "ARABIC", "Arabic", ""},
{20, "BULGARIAN", "Bulgarian", ""},
{21, "GREEK", "Greek", ""},
{22, "KOREAN", "Korean", ""},
{0, NULL, NULL, NULL}};
{0, "ENGLISH", 0, "English", ""},
{1, "JAPANESE", 0, "Japanese", ""},
{2, "DUTCH", 0, "Dutch", ""},
{3, "ITALIAN", 0, "Italian", ""},
{4, "GERMAN", 0, "German", ""},
{5, "FINNISH", 0, "Finnish", ""},
{6, "SWEDISH", 0, "Swedish", ""},
{7, "FRENCH", 0, "French", ""},
{8, "SPANISH", 0, "Spanish", ""},
{9, "CATALAN", 0, "Catalan", ""},
{10, "CZECH", 0, "Czech", ""},
{11, "BRAZILIAN_PORTUGUESE", 0, "Brazilian Portuguese", ""},
{12, "SIMPLIFIED_CHINESE", 0, "Simplified Chinese", ""},
{13, "RUSSIAN", 0, "Russian", ""},
{14, "CROATIAN", 0, "Croatian", ""},
{15, "SERBIAN", 0, "Serbian", ""},
{16, "UKRAINIAN", 0, "Ukrainian", ""},
{17, "POLISH", 0, "Polish", ""},
{18, "ROMANIAN", 0, "Romanian", ""},
{19, "ARABIC", 0, "Arabic", ""},
{20, "BULGARIAN", 0, "Bulgarian", ""},
{21, "GREEK", 0, "Greek", ""},
{22, "KOREAN", 0, "Korean", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "UserPreferencesLanguage", NULL);
RNA_def_struct_sdna(srna, "UserDef");
@ -1890,28 +1890,28 @@ static void rna_def_userdef_system(BlenderRNA *brna)
StructRNA *srna;
static EnumPropertyItem gl_texture_clamp_items[] = {
{0, "GL_CLAMP_OFF", "GL Texture Clamp Off", ""},
{8192, "GL_CLAMP_8192", "GL Texture Clamp 8192", ""},
{4096, "GL_CLAMP_4096", "GL Texture Clamp 4096", ""},
{2048, "GL_CLAMP_2048", "GL Texture Clamp 2048", ""},
{1024, "GL_CLAMP_1024", "GL Texture Clamp 1024", ""},
{512, "GL_CLAMP_512", "GL Texture Clamp 512", ""},
{256, "GL_CLAMP_256", "GL Texture Clamp 256", ""},
{128, "GL_CLAMP_128", "GL Texture Clamp 128", ""},
{0, NULL, NULL, NULL}};
{0, "GL_CLAMP_OFF", 0, "GL Texture Clamp Off", ""},
{8192, "GL_CLAMP_8192", 0, "GL Texture Clamp 8192", ""},
{4096, "GL_CLAMP_4096", 0, "GL Texture Clamp 4096", ""},
{2048, "GL_CLAMP_2048", 0, "GL Texture Clamp 2048", ""},
{1024, "GL_CLAMP_1024", 0, "GL Texture Clamp 1024", ""},
{512, "GL_CLAMP_512", 0, "GL Texture Clamp 512", ""},
{256, "GL_CLAMP_256", 0, "GL Texture Clamp 256", ""},
{128, "GL_CLAMP_128", 0, "GL Texture Clamp 128", ""},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem audio_mixing_samples_items[] = {
{256, "AUDIO_SAMPLES_256", "256", "Set audio mixing buffer size to 256 samples"},
{512, "AUDIO_SAMPLES_512", "512", "Set audio mixing buffer size to 512 samples"},
{1024, "AUDIO_SAMPLES_1024", "1024", "Set audio mixing buffer size to 1024 samples"},
{2048, "AUDIO_SAMPLES_2048", "2048", "Set audio mixing buffer size to 2048 samples"},
{0, NULL, NULL, NULL}};
{256, "AUDIO_SAMPLES_256", 0, "256", "Set audio mixing buffer size to 256 samples"},
{512, "AUDIO_SAMPLES_512", 0, "512", "Set audio mixing buffer size to 512 samples"},
{1024, "AUDIO_SAMPLES_1024", 0, "1024", "Set audio mixing buffer size to 1024 samples"},
{2048, "AUDIO_SAMPLES_2048", 0, "2048", "Set audio mixing buffer size to 2048 samples"},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem draw_method_items[] = {
{USER_DRAW_TRIPLE, "TRIPLE_BUFFER", "Triple Buffer", "Use a third buffer for minimal redraws at the cost of more memory."},
{USER_DRAW_OVERLAP, "OVERLAP", "Overlap", "Redraw all overlapping regions, minimal memory usage but more redraws."},
{USER_DRAW_FULL, "FULL", "Full", "Do a full redraw each time, slow, only use for reference or when all else fails."},
{0, NULL, NULL, NULL}};
{USER_DRAW_TRIPLE, "TRIPLE_BUFFER", 0, "Triple Buffer", "Use a third buffer for minimal redraws at the cost of more memory."},
{USER_DRAW_OVERLAP, "OVERLAP", 0, "Overlap", "Redraw all overlapping regions, minimal memory usage but more redraws."},
{USER_DRAW_FULL, "FULL", 0, "Full", "Do a full redraw each time, slow, only use for reference or when all else fails."},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "UserPreferencesSystem", NULL);
RNA_def_struct_sdna(srna, "UserDef");
@ -2075,14 +2075,14 @@ void RNA_def_userdef(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem user_pref_sections[] = {
{0, "VIEW_CONTROLS", "View & Controls", ""},
{1, "EDIT_METHODS", "Edit Methods", ""},
{2, "LANGUAGE_COLORS", "Language & Colors", ""},
{3, "AUTO_SAVE", "Auto Save", ""},
{4, "SYSTEM_OPENGL", "System & OpenGL", ""},
{5, "FILE_PATHS", "File Paths", ""},
{6, "THEMES", "Themes", ""},
{0, NULL, NULL, NULL}};
{0, "VIEW_CONTROLS", 0, "View & Controls", ""},
{1, "EDIT_METHODS", 0, "Edit Methods", ""},
{2, "LANGUAGE_COLORS", 0, "Language & Colors", ""},
{3, "AUTO_SAVE", 0, "Auto Save", ""},
{4, "SYSTEM_OPENGL", 0, "System & OpenGL", ""},
{5, "FILE_PATHS", 0, "File Paths", ""},
{6, "THEMES", 0, "Themes", ""},
{0, NULL, 0, NULL, NULL}};
rna_def_userdef_dothemes(brna);
rna_def_userdef_solidlight(brna);

16
source/blender/makesrna/intern/rna_vpaint.c
View File

@ -40,14 +40,14 @@ void RNA_def_vpaint(BlenderRNA *brna)
StructRNA *srna;
PropertyRNA *prop;
static EnumPropertyItem prop_mode_items[] = {
{0, "MIX", "Mix", "Use mix blending mode while painting."},
{1, "ADD", "Add", "Use add blending mode while painting."},
{2, "SUB", "Subtract", "Use subtract blending mode while painting."},
{3, "MUL", "Multiply", "Use multiply blending mode while painting."},
{4, "BLUR", "Blur", "Blur the color with surrounding values"},
{5, "LIGHTEN", "Lighten", "Use lighten blending mode while painting."},
{6, "DARKEN", "Darken", "Use darken blending mode while painting."},
{0, NULL, NULL, NULL}};
{0, "MIX", 0, "Mix", "Use mix blending mode while painting."},
{1, "ADD", 0, "Add", "Use add blending mode while painting."},
{2, "SUB", 0, "Subtract", "Use subtract blending mode while painting."},
{3, "MUL", 0, "Multiply", "Use multiply blending mode while painting."},
{4, "BLUR", 0, "Blur", "Blur the color with surrounding values"},
{5, "LIGHTEN", 0, "Lighten", "Use lighten blending mode while painting."},
{6, "DARKEN", 0, "Darken", "Use darken blending mode while painting."},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "VPaint", NULL);
RNA_def_struct_ui_text(srna, "Vertex Paint", "Properties of the Vpaint tool.");

66
source/blender/makesrna/intern/rna_world.c
View File

@ -74,13 +74,13 @@ static void rna_def_world_mtex(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem texco_items[] = {
{TEXCO_VIEW, "VIEW", "View", "Uses view vector for the texture coordinates."},
{TEXCO_GLOB, "GLOBAL", "Global", "Uses global coordinates for the texture coordinates (interior mist)."},
{TEXCO_ANGMAP, "ANGMAP", "AngMap", "Uses 360 degree angular coordinates, e.g. for spherical light probes."},
{TEXCO_H_SPHEREMAP, "SPHERE", "Sphere", "For 360 degree panorama sky, spherical mapped, only top half."},
{TEXCO_H_TUBEMAP, "TUBE", "Tube", "For 360 degree panorama sky, cylindrical mapped, only top half."},
{TEXCO_OBJECT, "OBJECT", "Object", "Uses linked object's coordinates for texture coordinates."},
{0, NULL, NULL, NULL}};
{TEXCO_VIEW, "VIEW", 0, "View", "Uses view vector for the texture coordinates."},
{TEXCO_GLOB, "GLOBAL", 0, "Global", "Uses global coordinates for the texture coordinates (interior mist)."},
{TEXCO_ANGMAP, "ANGMAP", 0, "AngMap", "Uses 360 degree angular coordinates, e.g. for spherical light probes."},
{TEXCO_H_SPHEREMAP, "SPHERE", 0, "Sphere", "For 360 degree panorama sky, spherical mapped, only top half."},
{TEXCO_H_TUBEMAP, "TUBE", 0, "Tube", "For 360 degree panorama sky, cylindrical mapped, only top half."},
{TEXCO_OBJECT, "OBJECT", 0, "Object", "Uses linked object's coordinates for texture coordinates."},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "WorldTextureSlot", "TextureSlot");
RNA_def_struct_sdna(srna, "MTex");
@ -126,27 +126,27 @@ static void rna_def_ambient_occlusion(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem blend_mode_items[] = {
{WO_AOADD, "ADD", "Add", "Add light and shadow."},
{WO_AOSUB, "SUBTRACT", "Subtract", "Subtract light and shadow (needs a normal light to make anything visible.)"},
{WO_AOADDSUB, "BOTH", "Both", "Both lighten and darken."},
{0, NULL, NULL, NULL}};
{WO_AOADD, "ADD", 0, "Add", "Add light and shadow."},
{WO_AOSUB, "SUBTRACT", 0, "Subtract", "Subtract light and shadow (needs a normal light to make anything visible.)"},
{WO_AOADDSUB, "BOTH", 0, "Both", "Both lighten and darken."},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem prop_color_items[] = {
{WO_AOPLAIN, "PLAIN", "White", "Plain diffuse energy (white.)"},
{WO_AOSKYCOL, "SKY_COLOR", "Sky Color", "Use horizon and zenith color for diffuse energy."},
{WO_AOSKYTEX, "SKY_TEXTURE", "Sky Texture", "Does full Sky texture render for diffuse energy."},
{0, NULL, NULL, NULL}};
{WO_AOPLAIN, "PLAIN", 0, "White", "Plain diffuse energy (white.)"},
{WO_AOSKYCOL, "SKY_COLOR", 0, "Sky Color", "Use horizon and zenith color for diffuse energy."},
{WO_AOSKYTEX, "SKY_TEXTURE", 0, "Sky Texture", "Does full Sky texture render for diffuse energy."},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem prop_sample_method_items[] = {
{WO_AOSAMP_CONSTANT, "CONSTANT_JITTERED", "Constant Jittered", ""},
{WO_AOSAMP_HALTON, "ADAPTIVE_QMC", "Adaptive QMC", "Fast in high-contrast areas."},
{WO_AOSAMP_HAMMERSLEY, "CONSTANT_QMC", "Constant QMC", "Best quality."},
{0, NULL, NULL, NULL}};
{WO_AOSAMP_CONSTANT, "CONSTANT_JITTERED", 0, "Constant Jittered", ""},
{WO_AOSAMP_HALTON, "ADAPTIVE_QMC", 0, "Adaptive QMC", "Fast in high-contrast areas."},
{WO_AOSAMP_HAMMERSLEY, "CONSTANT_QMC", 0, "Constant QMC", "Best quality."},
{0, NULL, 0, NULL, NULL}};
static EnumPropertyItem prop_gather_method_items[] = {
{WO_AOGATHER_RAYTRACE, "RAYTRACE", "Raytrace", "Accurate, but slow when noise-free results are required."},
{WO_AOGATHER_APPROX, "APPROXIMATE", "Approximate", "Inaccurate, but faster and without noise."},
{0, NULL, NULL, NULL}};
{WO_AOGATHER_RAYTRACE, "RAYTRACE", 0, "Raytrace", "Accurate, but slow when noise-free results are required."},
{WO_AOGATHER_APPROX, "APPROXIMATE", 0, "Approximate", "Inaccurate, but faster and without noise."},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "WorldAmbientOcclusion", NULL);
RNA_def_struct_sdna(srna, "World");
@ -241,10 +241,10 @@ static void rna_def_world_mist(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem falloff_items[] = {
{0, "QUADRATIC", "Quadratic", "Mist uses quadratic progression."},
{1, "LINEAR", "Linear", "Mist uses linear progression."},
{2, "INVERSE_QUADRATIC", "Inverse Quadratic", "Mist uses inverse quadratic progression."},
{0, NULL, NULL, NULL}};
{0, "QUADRATIC", 0, "Quadratic", "Mist uses quadratic progression."},
{1, "LINEAR", 0, "Linear", "Mist uses linear progression."},
{2, "INVERSE_QUADRATIC", 0, "Inverse Quadratic", "Mist uses inverse quadratic progression."},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "WorldMistSettings", NULL);
RNA_def_struct_sdna(srna, "World");
@ -335,13 +335,13 @@ void RNA_def_world(BlenderRNA *brna)
PropertyRNA *prop;
static EnumPropertyItem physics_engine_items[] = {
{WOPHY_NONE, "NONE", "None", ""},
//{WOPHY_ENJI, "ENJI", "Enji", ""},
{WOPHY_SUMO, "SUMO", "Sumo (Deprecated)", ""},
//{WOPHY_DYNAMO, "DYNAMO", "Dynamo", ""},
//{WOPHY_ODE, "ODE", "ODE", ""},
{WOPHY_BULLET, "BULLET", "Bullet", ""},
{0, NULL, NULL, NULL}};
{WOPHY_NONE, "NONE", 0, "None", ""},
//{WOPHY_ENJI, "ENJI", 0, "Enji", ""},
{WOPHY_SUMO, "SUMO", 0, "Sumo (Deprecated)", ""},
//{WOPHY_DYNAMO, "DYNAMO", 0, "Dynamo", ""},
//{WOPHY_ODE, "ODE", 0, "ODE", ""},
{WOPHY_BULLET, "BULLET", 0, "Bullet", ""},
{0, NULL, 0, NULL, NULL}};
srna= RNA_def_struct(brna, "World", "ID");
RNA_def_struct_ui_text(srna, "World", "World datablock describing the environment and ambient lighting of a scene.");

7
source/blender/python/intern/bpy_rna.c
View File

@ -481,7 +481,9 @@ int pyrna_py_to_prop(PointerRNA *ptr, PropertyRNA *prop, void *data, PyObject *v
BPy_StructRNA *param= (BPy_StructRNA*)value;
int raise_error= 0;
if(data) {
if(ptype == &RNA_AnyType) {
int flag = RNA_property_flag(prop);
if(flag & PROP_RNAPTR) {
if(value == Py_None)
memset(data, 0, sizeof(PointerRNA));
else
@ -1209,8 +1211,9 @@ PyObject *pyrna_param_to_py(PointerRNA *ptr, PropertyRNA *prop, void *data)
{
PointerRNA newptr;
StructRNA *type= RNA_property_pointer_type(ptr, prop);
int flag = RNA_property_flag(prop);
if(type == &RNA_AnyType) {
if(flag & PROP_RNAPTR) {
/* in this case we get the full ptr */
newptr= *(PointerRNA*)data;
}

20
source/blender/windowmanager/intern/wm_operators.c
View File

@ -1399,10 +1399,10 @@ void WM_radial_control_string(wmOperator *op, char str[], int maxlen)
void WM_OT_radial_control_partial(wmOperatorType *ot)
{
static EnumPropertyItem prop_mode_items[] = {
{WM_RADIALCONTROL_SIZE, "SIZE", "Size", ""},
{WM_RADIALCONTROL_STRENGTH, "STRENGTH", "Strength", ""},
{WM_RADIALCONTROL_ANGLE, "ANGLE", "Angle", ""},
{0, NULL, NULL, NULL}};
{WM_RADIALCONTROL_SIZE, "SIZE", 0, "Size", ""},
{WM_RADIALCONTROL_STRENGTH, "STRENGTH", 0, "Strength", ""},
{WM_RADIALCONTROL_ANGLE, "ANGLE", 0, "Angle", ""},
{0, NULL, 0, NULL, NULL}};
/* Should be set in custom invoke() */
RNA_def_float(ot->srna, "initial_value", 0, 0, FLT_MAX, "Initial Value", "", 0, FLT_MAX);
@ -1484,12 +1484,12 @@ static int ten_timer_exec(bContext *C, wmOperator *op)
static void WM_OT_ten_timer(wmOperatorType *ot)
{
static EnumPropertyItem prop_type_items[] = {
{0, "DRAW", "Draw Region", ""},
{1, "DRAWSWAP", "Draw Region + Swap", ""},
{2, "DRAWWINSWAP", "Draw Window + Swap", ""},
{3, "ANIMSTEP", "Anim Step", ""},
{4, "UNDO", "Undo/Redo", ""},
{0, NULL, NULL, NULL}};
{0, "DRAW", 0, "Draw Region", ""},
{1, "DRAWSWAP", 0, "Draw Region + Swap", ""},
{2, "DRAWWINSWAP", 0, "Draw Window + Swap", ""},
{3, "ANIMSTEP", 0, "Anim Step", ""},
{4, "UNDO", 0, "Undo/Redo", ""},
{0, NULL, 0, NULL, NULL}};
ot->name= "Ten Timer";
ot->idname= "WM_OT_ten_timer";