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

Face Maps: custom-data, UI and RNA API

Browse Source 
Add face maps, needed for face-map widgets,
only data structure, widgets will be separate commit.

This comes from 'custom-manipulator' branch with only minor changes.
This commit is contained in:
Campbell Barton 2017-05-30 17:58:24 +10:00
parent d321ed62b8
commit d888453244
16 changed files with 1157 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
release/scripts/startup/bl_ui/properties_data_mesh.py
View File

@ -76,6 +76,17 @@ class MESH_UL_vgroups(UIList):
layout.label(text="", icon_value=icon)
class MESH_UL_fmaps(UIList):
def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
# assert(isinstance(item, bpy.types.FaceMap))
fmap = item
if self.layout_type in {'DEFAULT', 'COMPACT'}:
layout.prop(fmap, "name", text="", emboss=False, icon_value=icon)
elif self.layout_type in {'GRID'}:
layout.alignment = 'CENTER'
layout.label(text="", icon_value=icon)
class MESH_UL_shape_keys(UIList):
def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
# assert(isinstance(item, bpy.types.ShapeKey))
@ -227,6 +238,47 @@ class DATA_PT_vertex_groups(MeshButtonsPanel, Panel):
layout.prop(context.tool_settings, "vertex_group_weight", text="Weight")
class DATA_PT_face_maps(MeshButtonsPanel, Panel):
bl_label = "Face Maps"
COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
@classmethod
def poll(cls, context):
obj = context.object
return (obj and obj.type == 'MESH')
def draw(self, context):
layout = self.layout
ob = context.object
facemap = ob.face_maps.active
rows = 2
if facemap:
rows = 4
row = layout.row()
row.template_list("MESH_UL_fmaps", "", ob, "face_maps", ob.face_maps, "active_index", rows=rows)
col = row.column(align=True)
col.operator("object.face_map_add", icon='ZOOMIN', text="")
col.operator("object.face_map_remove", icon='ZOOMOUT', text="")
if facemap:
col.separator()
col.operator("object.face_map_move", icon='TRIA_UP', text="").direction = 'UP'
col.operator("object.face_map_move", icon='TRIA_DOWN', text="").direction = 'DOWN'
if ob.face_maps and (ob.mode == 'EDIT' and ob.type == 'MESH'):
row = layout.row()
sub = row.row(align=True)
sub.operator("object.face_map_assign", text="Assign")
sub.operator("object.face_map_remove_from", text="Remove")
sub = row.row(align=True)
sub.operator("object.face_map_select", text="Select")
sub.operator("object.face_map_deselect", text="Deselect")
class DATA_PT_shape_keys(MeshButtonsPanel, Panel):
bl_label = "Shape Keys"
COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME', 'BLENDER_CLAY', 'BLENDER_EEVEE'}
@ -396,12 +448,14 @@ classes = (
MESH_MT_vertex_group_specials,
MESH_MT_shape_key_specials,
MESH_UL_vgroups,
MESH_UL_fmaps,
MESH_UL_shape_keys,
MESH_UL_uvmaps_vcols,
DATA_PT_context_mesh,
DATA_PT_normals,
DATA_PT_texture_space,
DATA_PT_vertex_groups,
DATA_PT_face_maps,
DATA_PT_shape_keys,
DATA_PT_uv_texture,
DATA_PT_vertex_colors,

53
source/blender/blenkernel/BKE_object_facemap.h Normal file
View File

@ -0,0 +1,53 @@
/*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* Contributor(s): Antony Riakiotakis
*
* ***** END GPL LICENSE BLOCK *****
*/
#ifndef __BKE_OBJECT_FACEMAP_H__
#define __BKE_OBJECT_FACEMAP_H__
/** \file BKE_object_facemap.h
* \ingroup bke
* \brief Functions for dealing with object face-maps.
*/
#ifdef __cplusplus
extern "C" {
#endif
struct bFaceMap;
struct ListBase;
struct Object;
struct bFaceMap *BKE_object_facemap_add(struct Object *ob);
struct bFaceMap *BKE_object_facemap_add_name(struct Object *ob, const char *name);
void BKE_object_facemap_remove(struct Object *ob, struct bFaceMap *fmap);
void BKE_object_facemap_clear(struct Object *ob);
int BKE_object_facemap_name_index(struct Object *ob, const char *name);
void BKE_object_facemap_unique_name(struct Object *ob, struct bFaceMap *fmap);
struct bFaceMap *BKE_object_facemap_find_name(struct Object *ob, const char *name);
void BKE_object_facemap_copy_list(struct ListBase *outbase, struct ListBase *inbase);
#ifdef __cplusplus
}
#endif
#endif /* __BKE_OBJECT_FACEMAP_H__ */

2
source/blender/blenkernel/CMakeLists.txt
View File

@ -145,6 +145,7 @@ set(SRC
intern/nla.c
intern/node.c
intern/object.c
intern/object_facemap.c
intern/object_deform.c
intern/object_dupli.c
intern/object_update.c
@ -271,6 +272,7 @@ set(SRC
BKE_nla.h
BKE_node.h
BKE_object.h
BKE_object_facemap.h
BKE_object_deform.h
BKE_ocean.h
BKE_outliner_treehash.h

7
source/blender/blenkernel/intern/object.c
View File

@ -103,6 +103,7 @@
#include "BKE_multires.h"
#include "BKE_node.h"
#include "BKE_object.h"
#include "BKE_object_facemap.h"
#include "BKE_paint.h"
#include "BKE_particle.h"
#include "BKE_pointcache.h"
@ -422,6 +423,7 @@ void BKE_object_free(Object *ob)
MEM_SAFE_FREE(ob->bb);
BLI_freelistN(&ob->defbase);
BLI_freelistN(&ob->fmaps);
if (ob->pose) {
BKE_pose_free_ex(ob->pose, false);
ob->pose = NULL;
@ -1151,6 +1153,7 @@ Object *BKE_object_copy_ex(Main *bmain, Object *ob, bool copy_caches)
BKE_pose_rebuild(obn, obn->data);
}
defgroup_copy_list(&obn->defbase, &ob->defbase);
BKE_object_facemap_copy_list(&obn->fmaps, &ob->fmaps);
BKE_constraints_copy(&obn->constraints, &ob->constraints, true);
obn->mode = OB_MODE_OBJECT;
@ -1279,10 +1282,10 @@ static void armature_set_id_extern(Object *ob)
unsigned int lay = arm->layer_protected;
for (pchan = ob->pose->chanbase.first; pchan; pchan = pchan->next) {
if (!(pchan->bone->layer & lay))
if (!(pchan->bone->layer & lay)) {
id_lib_extern((ID *)pchan->custom);
}
}
}
void BKE_object_copy_proxy_drivers(Object *ob, Object *target)

259
source/blender/blenkernel/intern/object_facemap.c Normal file
View File

@ -0,0 +1,259 @@
/*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2008 Blender Foundation.
* All rights reserved.
*
*
* Contributor(s): Blender Foundation
*
* ***** END GPL LICENSE BLOCK *****
*/
/** \file blender/blenkernel/intern/object_facemap.c
* \ingroup bke
*/
#include <string.h>
#include "DNA_object_types.h"
#include "DNA_mesh_types.h"
#include "BKE_context.h"
#include "BKE_customdata.h"
#include "BKE_editmesh.h"
#include "BKE_object.h"
#include "BKE_object_facemap.h" /* own include */
#include "BKE_object_deform.h"
#include "BKE_depsgraph.h"
#include "BLI_utildefines.h"
#include "BLI_path_util.h"
#include "BLI_string.h"
#include "BLI_string_utils.h"
#include "BLI_listbase.h"
#include "BLT_translation.h"
#include "MEM_guardedalloc.h"
#include "RNA_define.h"
#include "RNA_access.h"
static bool fmap_unique_check(void *arg, const char *name)
{
struct {Object *ob; void *fm; } *data = arg;
bFaceMap *fmap;
for (fmap = data->ob->fmaps.first; fmap; fmap = fmap->next) {
if (data->fm != fmap) {
if (!strcmp(fmap->name, name)) {
return true;
}
}
}
return false;
}
static bFaceMap *fmap_duplicate(bFaceMap *infmap)
{
bFaceMap *outfmap;
if (!infmap)
return NULL;
outfmap = MEM_callocN(sizeof(bFaceMap), "copy facemap");
/* For now, just copy everything over. */
memcpy(outfmap, infmap, sizeof(bFaceMap));
outfmap->next = outfmap->prev = NULL;
return outfmap;
}
void BKE_object_facemap_copy_list(ListBase *outbase, ListBase *inbase)
{
bFaceMap *fmap, *fmapn;
BLI_listbase_clear(outbase);
for (fmap = inbase->first; fmap; fmap = fmap->next) {
fmapn = fmap_duplicate(fmap);
BLI_addtail(outbase, fmapn);
}
}
void BKE_object_facemap_unique_name(Object *ob, bFaceMap *fmap)
{
struct {Object *ob; void *fmap; } data;
data.ob = ob;
data.fmap = fmap;
BLI_uniquename_cb(fmap_unique_check, &data, DATA_("Group"), '.', fmap->name, sizeof(fmap->name));
}
bFaceMap *BKE_object_facemap_add_name(Object *ob, const char *name)
{
bFaceMap *fmap;
if (!ob || ob->type != OB_MESH)
return NULL;
fmap = MEM_callocN(sizeof(bFaceMap), __func__);
BLI_strncpy(fmap->name, name, sizeof(fmap->name));
BLI_addtail(&ob->fmaps, fmap);
ob->actfmap = BLI_listbase_count(&ob->fmaps);
BKE_object_facemap_unique_name(ob, fmap);
return fmap;
}
bFaceMap *BKE_object_facemap_add(Object *ob)
{
return BKE_object_facemap_add_name(ob, DATA_("FaceMap"));
}
static void object_fmap_remove_edit_mode(Object *ob, bFaceMap *fmap, bool do_selected, bool purge)
{
const int fmap_nr = BLI_findindex(&ob->fmaps, fmap);
if (ob->type == OB_MESH) {
Mesh *me = ob->data;
if (me->edit_btmesh) {
BMEditMesh *em = me->edit_btmesh;
const int cd_fmap_offset = CustomData_get_offset(&em->bm->pdata, CD_FACEMAP);
if (cd_fmap_offset != -1) {
BMFace *efa;
BMIter iter;
int *map;
if (purge) {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
map = BM_ELEM_CD_GET_VOID_P(efa, cd_fmap_offset);
if (map) {
if (*map == fmap_nr)
*map = -1;
else if (*map > fmap_nr)
*map -= 1;
}
}
}
else {
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
map = BM_ELEM_CD_GET_VOID_P(efa, cd_fmap_offset);
if (map && *map == fmap_nr && (!do_selected || BM_elem_flag_test(efa, BM_ELEM_SELECT))) {
*map = -1;
}
}
}
}
if (ob->actfmap == BLI_listbase_count(&ob->fmaps))
ob->actfmap--;
BLI_remlink(&ob->fmaps, fmap);
MEM_freeN(fmap);
}
}
}
static void object_fmap_remove_object_mode(Object *ob, bFaceMap *fmap, bool purge)
{
const int fmap_nr = BLI_findindex(&ob->fmaps, fmap);
if (ob->type == OB_MESH) {
Mesh *me = ob->data;
if (CustomData_has_layer(&me->pdata, CD_FACEMAP)) {
int *map = CustomData_get_layer(&me->pdata, CD_FACEMAP);
int i;
if (map) {
for (i = 0; i < me->totpoly; i++) {
if (map[i] == fmap_nr)
map[i] = -1;
else if (purge && map[i] > fmap_nr)
map[i]--;
}
}
}
if (ob->actfmap == BLI_listbase_count(&ob->fmaps))
ob->actfmap--;
BLI_remlink(&ob->fmaps, fmap);
MEM_freeN(fmap);
}
}
static void fmap_remove_exec(Object *ob, bFaceMap *fmap, const bool is_edit_mode, const bool purge)
{
if (is_edit_mode)
object_fmap_remove_edit_mode(ob, fmap, false, purge);
else
object_fmap_remove_object_mode(ob, fmap, purge);
}
void BKE_object_facemap_remove(Object *ob, bFaceMap *fmap)
{
fmap_remove_exec(ob, fmap, BKE_object_is_in_editmode(ob), true);
}
void BKE_object_facemap_clear(Object *ob)
{
bFaceMap *fmap = (bFaceMap *)ob->fmaps.first;
if (fmap) {
const bool edit_mode = BKE_object_is_in_editmode_vgroup(ob);
while (fmap) {
bFaceMap *next_fmap = fmap->next;
fmap_remove_exec(ob, fmap, edit_mode, false);
fmap = next_fmap;
}
}
/* remove all face-maps */
if (ob->type == OB_MESH) {
Mesh *me = ob->data;
CustomData_free_layer(&me->pdata, CD_FACEMAP, me->totpoly, 0);
}
ob->actfmap = 0;
}
int BKE_object_facemap_name_index(Object *ob, const char *name)
{
return (name) ? BLI_findstringindex(&ob->fmaps, name, offsetof(bFaceMap, name)) : -1;
}
bFaceMap *BKE_object_facemap_find_name(Object *ob, const char *name)
{
return BLI_findstring(&ob->fmaps, name, offsetof(bFaceMap, name));
}

1
source/blender/blenloader/intern/readfile.c
View File

@ -5392,6 +5392,7 @@ static void direct_link_object(FileData *fd, Object *ob)
direct_link_motionpath(fd, ob->mpath);
link_list(fd, &ob->defbase);
link_list(fd, &ob->fmaps);
// XXX deprecated - old animation system <<<
direct_link_nlastrips(fd, &ob->nlastrips);
link_list(fd, &ob->constraintChannels);

12
source/blender/blenloader/intern/writefile.c
View File

@ -1688,6 +1688,13 @@ static void write_defgroups(WriteData *wd, ListBase *defbase)
}
}
static void write_fmaps(WriteData *wd, ListBase *fbase)
{
for (bFaceMap *fmap = fbase->first; fmap; fmap = fmap->next) {
writestruct(wd, DATA, bFaceMap, 1, fmap);
}
}
static void write_modifiers(WriteData *wd, ListBase *modbase)
{
ModifierData *md;
@ -1891,6 +1898,7 @@ static void write_object(WriteData *wd, Object *ob)
write_pose(wd, ob->pose);
write_defgroups(wd, &ob->defbase);
write_fmaps(wd, &ob->fmaps);
write_constraints(wd, &ob->constraints);
write_motionpath(wd, ob->mpath);
@ -2123,6 +2131,10 @@ static void write_customdata(
else if (layer->type == CD_GRID_PAINT_MASK) {
write_grid_paint_mask(wd, count, layer->data);
}
else if (layer->type == CD_FACEMAP) {
const int *layer_data = layer->data;
writedata(wd, DATA, sizeof(*layer_data) * count, layer_data);
}
else {
CustomData_file_write_info(layer->type, &structname, &structnum);
if (structnum) {

5
source/blender/editors/include/ED_mesh.h
View File

@ -39,6 +39,7 @@ struct ID;
struct View3D;
struct ARegion;
struct bContext;
struct bFaceMap;
struct wmOperator;
struct wmKeyConfig;
struct ReportList;
@ -260,6 +261,10 @@ float ED_vgroup_vert_weight(struct Object *ob, struct bDeformGrou
void ED_vgroup_vert_active_mirror(struct Object *ob, int def_nr);
/* object_facemap_ops.c */
void ED_object_facemap_face_add(struct Object *ob, struct bFaceMap *fmap, int facenum);
void ED_object_facemap_face_remove(struct Object *ob, struct bFaceMap *fmap, int facenum);
/* mesh_data.c */
// void ED_mesh_geometry_add(struct Mesh *mesh, struct ReportList *reports, int verts, int edges, int faces);
void ED_mesh_polys_add(struct Mesh *mesh, struct ReportList *reports, int count);

1
source/blender/editors/object/CMakeLists.txt
View File

@ -47,6 +47,7 @@ set(SRC
object_bake_api.c
object_constraint.c
object_edit.c
object_facemap_ops.c
object_group.c
object_hook.c
object_lattice.c

493
source/blender/editors/object/object_facemap_ops.c Normal file
View File

@ -0,0 +1,493 @@
/*
* ***** BEGIN GPL LICENSE BLOCK *****
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2008 Blender Foundation.
* All rights reserved.
*
*
* Contributor(s): Blender Foundation
*
* ***** END GPL LICENSE BLOCK *****
*/
#include "DNA_object_types.h"
#include "DNA_mesh_types.h"
#include "WM_types.h"
#include "WM_api.h"
#include "BKE_context.h"
#include "BKE_customdata.h"
#include "BKE_editmesh.h"
#include "BKE_object.h"
#include "BKE_object_facemap.h"
#include "BKE_object_deform.h"
#include "BKE_depsgraph.h"
#include "BLI_utildefines.h"
#include "BLI_path_util.h"
#include "BLI_string.h"
#include "BLI_listbase.h"
#include "MEM_guardedalloc.h"
#include "ED_mesh.h"
#include "ED_object.h"
#include "RNA_define.h"
#include "RNA_access.h"
#include <string.h>
#include "object_intern.h"
/* called while not in editmode */
void ED_object_facemap_face_add(Object *ob, bFaceMap *fmap, int facenum)
{
int fmap_nr;
if (GS(((ID *)ob->data)->name) != ID_ME)
return;
/* get the face map number, exit if it can't be found */
fmap_nr = BLI_findindex(&ob->fmaps, fmap);
if (fmap_nr != -1) {
int *facemap;
Mesh *me = ob->data;
/* if there's is no facemap layer then create one */
if ((facemap = CustomData_get_layer(&me->pdata, CD_FACEMAP)) == NULL)
facemap = CustomData_add_layer(&me->pdata, CD_FACEMAP, CD_DEFAULT, NULL, me->totpoly);
facemap[facenum] = fmap_nr;
}
}
/* called while not in editmode */
void ED_object_facemap_face_remove(Object *ob, bFaceMap *fmap, int facenum)
{
int fmap_nr;
if (GS(((ID *)ob->data)->name) != ID_ME)
return;
/* get the face map number, exit if it can't be found */
fmap_nr = BLI_findindex(&ob->fmaps, fmap);
if (fmap_nr != -1) {
int *facemap;
Mesh *me = ob->data;
/* if there's is no facemap layer then create one */
if ((facemap = CustomData_get_layer(&me->pdata, CD_FACEMAP)) == NULL)
return;
facemap[facenum] = -1;
}
}
static void object_fmap_swap_edit_mode(Object *ob, int num1, int num2)
{
if (ob->type == OB_MESH) {
Mesh *me = ob->data;
if (me->edit_btmesh) {
BMEditMesh *em = me->edit_btmesh;
const int cd_fmap_offset = CustomData_get_offset(&em->bm->pdata, CD_FACEMAP);
if (cd_fmap_offset != -1) {
BMFace *efa;
BMIter iter;
int *map;
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
map = BM_ELEM_CD_GET_VOID_P(efa, cd_fmap_offset);
if (map) {
if (num1 != -1) {
if (*map == num1)
*map = num2;
else if (*map == num2)
*map = num1;
}
}
}
}
}
}
}
static void object_fmap_swap_object_mode(Object *ob, int num1, int num2)
{
if (ob->type == OB_MESH) {
Mesh *me = ob->data;
if (CustomData_has_layer(&me->pdata, CD_FACEMAP)) {
int *map = CustomData_get_layer(&me->pdata, CD_FACEMAP);
int i;
if (map) {
for (i = 0; i < me->totpoly; i++) {
if (num1 != -1) {
if (map[i] == num1)
map[i] = num2;
else if (map[i]== num2)
map[i] = num1;
}
}
}
}
}
}
static void object_facemap_swap(Object *ob, int num1, int num2)
{
if (BKE_object_is_in_editmode(ob))
object_fmap_swap_edit_mode(ob, num1, num2);
else
object_fmap_swap_object_mode(ob, num1, num2);
}
static int face_map_supported_poll(bContext *C)
{
Object *ob = ED_object_context(C);
ID *data = (ob) ? ob->data : NULL;
return (ob && !ob->id.lib && ob->type == OB_MESH && data && !data->lib);
}
static int face_map_supported_edit_mode_poll(bContext *C)
{
Object *ob = ED_object_context(C);
ID *data = (ob) ? ob->data : NULL;
return (ob && !ob->id.lib && ob->type == OB_MESH && data && !data->lib && ob->mode == OB_MODE_EDIT);
}
static int face_map_add_exec(bContext *C, wmOperator *UNUSED(op))
{
Object *ob = ED_object_context(C);
BKE_object_facemap_add(ob);
DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
WM_event_add_notifier(C, NC_GEOM | ND_DATA, ob->data);
WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
return OPERATOR_FINISHED;
}
void OBJECT_OT_face_map_add(struct wmOperatorType *ot)
{
/* identifiers */
ot->name = "Add Face Map";
ot->idname = "OBJECT_OT_face_map_add";
ot->description = "Add a new face map to the active object";
/* api callbacks */
ot->poll = face_map_supported_poll;
ot->exec = face_map_add_exec;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
}
static int face_map_remove_exec(bContext *C, wmOperator *UNUSED(op))
{
Object *ob = ED_object_context(C);
bFaceMap *fmap = BLI_findlink(&ob->fmaps, ob->actfmap - 1);
if (fmap) {
BKE_object_facemap_remove(ob, fmap);
DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
WM_event_add_notifier(C, NC_GEOM | ND_DATA, ob->data);
WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
}
return OPERATOR_FINISHED;
}
void OBJECT_OT_face_map_remove(struct wmOperatorType *ot)
{
/* identifiers */
ot->name = "Remove Face Map";
ot->idname = "OBJECT_OT_face_map_remove";
ot->description = "Remove a face map from the active object";
/* api callbacks */
ot->poll = face_map_supported_poll;
ot->exec = face_map_remove_exec;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
}
static int face_map_assign_exec(bContext *C, wmOperator *UNUSED(op))
{
Object *ob = ED_object_context(C);
bFaceMap *fmap = BLI_findlink(&ob->fmaps, ob->actfmap - 1);
if (fmap) {
Mesh *me = ob->data;
BMEditMesh *em = me->edit_btmesh;
BMFace *efa;
BMIter iter;
int *map;
int cd_fmap_offset;
if (!CustomData_has_layer(&em->bm->pdata, CD_FACEMAP))
BM_data_layer_add(em->bm, &em->bm->pdata, CD_FACEMAP);
cd_fmap_offset = CustomData_get_offset(&em->bm->pdata, CD_FACEMAP);
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
map = BM_ELEM_CD_GET_VOID_P(efa, cd_fmap_offset);
if (BM_elem_flag_test(efa, BM_ELEM_SELECT)) {
*map = ob->actfmap - 1;
}
}
DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
WM_event_add_notifier(C, NC_GEOM | ND_DATA, ob->data);
WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
}
return OPERATOR_FINISHED;
}
void OBJECT_OT_face_map_assign(struct wmOperatorType *ot)
{
/* identifiers */
ot->name = "Assign Face Map";
ot->idname = "OBJECT_OT_face_map_assign";
ot->description = "Assign faces to a face map";
/* api callbacks */
ot->poll = face_map_supported_edit_mode_poll;
ot->exec = face_map_assign_exec;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
}
static int face_map_remove_from_exec(bContext *C, wmOperator *UNUSED(op))
{
Object *ob = ED_object_context(C);
bFaceMap *fmap = BLI_findlink(&ob->fmaps, ob->actfmap - 1);
if (fmap) {
Mesh *me = ob->data;
BMEditMesh *em = me->edit_btmesh;
BMFace *efa;
BMIter iter;
int *map;
int cd_fmap_offset;
int mapindex = ob->actfmap - 1;
if (!CustomData_has_layer(&em->bm->pdata, CD_FACEMAP))
return OPERATOR_CANCELLED;
cd_fmap_offset = CustomData_get_offset(&em->bm->pdata, CD_FACEMAP);
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
map = BM_ELEM_CD_GET_VOID_P(efa, cd_fmap_offset);
if (BM_elem_flag_test(efa, BM_ELEM_SELECT) && *map == mapindex) {
*map = -1;
}
}
DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
WM_event_add_notifier(C, NC_GEOM | ND_DATA, ob->data);
WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
}
return OPERATOR_FINISHED;
}
void OBJECT_OT_face_map_remove_from(struct wmOperatorType *ot)
{
/* identifiers */
ot->name = "Remove From Face Map";
ot->idname = "OBJECT_OT_face_map_remove_from";
ot->description = "Remove faces from a face map";
/* api callbacks */
ot->poll = face_map_supported_edit_mode_poll;
ot->exec = face_map_remove_from_exec;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
}
static void fmap_select(Object *ob, bool select)
{
Mesh *me = ob->data;
BMEditMesh *em = me->edit_btmesh;
BMFace *efa;
BMIter iter;
int *map;
int cd_fmap_offset;
int mapindex = ob->actfmap - 1;
if (!CustomData_has_layer(&em->bm->pdata, CD_FACEMAP))
BM_data_layer_add(em->bm, &em->bm->pdata, CD_FACEMAP);
cd_fmap_offset = CustomData_get_offset(&em->bm->pdata, CD_FACEMAP);
BM_ITER_MESH (efa, &iter, em->bm, BM_FACES_OF_MESH) {
map = BM_ELEM_CD_GET_VOID_P(efa, cd_fmap_offset);
if (*map == mapindex) {
BM_face_select_set(em->bm, efa, select);
}
}
}
static int face_map_select_exec(bContext *C, wmOperator *UNUSED(op))
{
Object *ob = ED_object_context(C);
bFaceMap *fmap = BLI_findlink(&ob->fmaps, ob->actfmap - 1);
if (fmap) {
fmap_select(ob, true);
DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
WM_event_add_notifier(C, NC_GEOM | ND_DATA, ob->data);
WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
}
return OPERATOR_FINISHED;
}
void OBJECT_OT_face_map_select(struct wmOperatorType *ot)
{
/* identifiers */
ot->name = "Select Face Map Faces";
ot->idname = "OBJECT_OT_face_map_select";
ot->description = "Select faces belonging to a face map";
/* api callbacks */
ot->poll = face_map_supported_edit_mode_poll;
ot->exec = face_map_select_exec;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
}
static int face_map_deselect_exec(bContext *C, wmOperator *UNUSED(op))
{
Object *ob = ED_object_context(C);
bFaceMap *fmap = BLI_findlink(&ob->fmaps, ob->actfmap - 1);
if (fmap) {
fmap_select(ob, false);
DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
WM_event_add_notifier(C, NC_GEOM | ND_DATA, ob->data);
WM_event_add_notifier(C, NC_OBJECT | ND_DRAW, ob);
}
return OPERATOR_FINISHED;
}
void OBJECT_OT_face_map_deselect(struct wmOperatorType *ot)
{
/* identifiers */
ot->name = "Deselect Face Map Faces";
ot->idname = "OBJECT_OT_face_map_deselect";
ot->description = "Deselect faces belonging to a face map";
/* api callbacks */
ot->poll = face_map_supported_edit_mode_poll;
ot->exec = face_map_deselect_exec;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
}
static int face_map_move_exec(bContext *C, wmOperator *op)
{
Object *ob = ED_object_context(C);
bFaceMap *fmap;
int dir = RNA_enum_get(op->ptr, "direction");
int pos1, pos2 = -1, count;
fmap = BLI_findlink(&ob->fmaps, ob->actfmap - 1);
if (!fmap) {
return OPERATOR_CANCELLED;
}
count = BLI_listbase_count(&ob->fmaps);
pos1 = BLI_findindex(&ob->fmaps, fmap);
if (dir == 1) { /*up*/
void *prev = fmap->prev;
if (prev) {
pos2 = pos1 - 1;
}
else {
pos2 = count - 1;
}
BLI_remlink(&ob->fmaps, fmap);
BLI_insertlinkbefore(&ob->fmaps, prev, fmap);
}
else { /*down*/
void *next = fmap->next;
if (next) {
pos2 = pos1 + 1;
}
else {
pos2 = 0;
}
BLI_remlink(&ob->fmaps, fmap);
BLI_insertlinkafter(&ob->fmaps, next, fmap);
}
/* iterate through mesh and substitute the indices as necessary */
object_facemap_swap(ob, pos2, pos1);
ob->actfmap = pos2 + 1;
DAG_id_tag_update(&ob->id, OB_RECALC_DATA);
WM_event_add_notifier(C, NC_GEOM | ND_VERTEX_GROUP, ob);
return OPERATOR_FINISHED;
}
void OBJECT_OT_face_map_move(wmOperatorType *ot)
{
static EnumPropertyItem fmap_slot_move[] = {
{1, "UP", 0, "Up", ""},
{-1, "DOWN", 0, "Down", ""},
{0, NULL, 0, NULL, NULL}
};
/* identifiers */
ot->name = "Move Face Map";
ot->idname = "OBJECT_OT_face_map_move";
ot->description = "Move the active face map up/down in the list";
/* api callbacks */
ot->poll = face_map_supported_poll;
ot->exec = face_map_move_exec;
/* flags */
ot->flag = OPTYPE_REGISTER | OPTYPE_UNDO;
RNA_def_enum(ot->srna, "direction", fmap_slot_move, 0, "Direction", "Direction to move, UP or DOWN");
}

9
source/blender/editors/object/object_intern.h
View File

@ -242,6 +242,15 @@ void OBJECT_OT_vertex_weight_set_active(struct wmOperatorType *ot);
void OBJECT_OT_vertex_weight_normalize_active_vertex(struct wmOperatorType *ot);
void OBJECT_OT_vertex_weight_copy(struct wmOperatorType *ot);
/* object_facemap_ops.c */
void OBJECT_OT_face_map_add(struct wmOperatorType *ot);
void OBJECT_OT_face_map_remove(struct wmOperatorType *ot);
void OBJECT_OT_face_map_assign(struct wmOperatorType *ot);
void OBJECT_OT_face_map_remove_from(struct wmOperatorType *ot);
void OBJECT_OT_face_map_select(struct wmOperatorType *ot);
void OBJECT_OT_face_map_deselect(struct wmOperatorType *ot);
void OBJECT_OT_face_map_move(struct wmOperatorType *ot);
/* object_warp.c */
void TRANSFORM_OT_vertex_warp(struct wmOperatorType *ot);

8
source/blender/editors/object/object_ops.c
View File

@ -196,6 +196,14 @@ void ED_operatortypes_object(void)
WM_operatortype_append(OBJECT_OT_vertex_weight_normalize_active_vertex);
WM_operatortype_append(OBJECT_OT_vertex_weight_copy);
WM_operatortype_append(OBJECT_OT_face_map_add);
WM_operatortype_append(OBJECT_OT_face_map_remove);
WM_operatortype_append(OBJECT_OT_face_map_assign);
WM_operatortype_append(OBJECT_OT_face_map_remove_from);
WM_operatortype_append(OBJECT_OT_face_map_select);
WM_operatortype_append(OBJECT_OT_face_map_deselect);
WM_operatortype_append(OBJECT_OT_face_map_move);
WM_operatortype_append(TRANSFORM_OT_vertex_warp);
WM_operatortype_append(OBJECT_OT_game_property_new);

4
source/blender/makesdna/DNA_customdata_types.h
View File

@ -92,7 +92,7 @@ typedef enum CustomDataType {
CD_MCOL = 6,
CD_ORIGINDEX = 7,
CD_NORMAL = 8,
/* CD_POLYINDEX = 9, */
CD_FACEMAP = 9, /* exclusive face group, each face can only be part of one */
CD_PROP_FLT = 10,
CD_PROP_INT = 11,
CD_PROP_STR = 12,
@ -143,7 +143,7 @@ typedef enum CustomDataType {
#define CD_MASK_MCOL (1 << CD_MCOL)
#define CD_MASK_ORIGINDEX (1 << CD_ORIGINDEX)
#define CD_MASK_NORMAL (1 << CD_NORMAL)
// #define CD_MASK_POLYINDEX (1 << CD_POLYINDEX)
#define CD_MASK_FACEMAP (1 << CD_FACEMAP)
#define CD_MASK_PROP_FLT (1 << CD_PROP_FLT)
#define CD_MASK_PROP_INT (1 << CD_PROP_INT)
#define CD_MASK_PROP_STR (1 << CD_PROP_STR)

13
source/blender/makesdna/DNA_object_types.h
View File

@ -65,6 +65,14 @@ typedef struct bDeformGroup {
/* need this flag for locking weights */
char flag, pad[7];
} bDeformGroup;
/* Face Maps*/
typedef struct bFaceMap {
struct bFaceMap *next, *prev;
char name[64]; /* MAX_VGROUP_NAME */
} bFaceMap;
#define MAX_VGROUP_NAME 64
/* bDeformGroup->flag */
@ -142,7 +150,8 @@ typedef struct Object {
ListBase effect DNA_DEPRECATED; // XXX deprecated... keep for readfile
ListBase defbase; /* list of bDeformGroup (vertex groups) names and flag only */
ListBase modifiers; /* list of ModifierData structures */
ListBase fmaps; /* list of facemaps */
int mode; /* Local object mode */
int restore_mode; /* Keep track of what mode to return to after toggling a mode */
@ -251,6 +260,8 @@ typedef struct Object {
short index; /* custom index, for renderpasses */
unsigned short actdef; /* current deformation group, note: index starts at 1 */
unsigned short actfmap; /* current face map, note: index starts at 1 */
unsigned char pad5[6];
float col[4]; /* object color */
int gameflag;

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

@ -231,6 +231,7 @@ extern StructRNA RNA_EnvironmentMapTexture;
extern StructRNA RNA_Event;
extern StructRNA RNA_ExplodeModifier;
extern StructRNA RNA_ExpressionController;
extern StructRNA RNA_FaceMap;
extern StructRNA RNA_FCurve;
extern StructRNA RNA_FCurveSample;
extern StructRNA RNA_FFmpegSettings;

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

@ -47,6 +47,7 @@
#include "BKE_editmesh.h"
#include "BKE_group.h" /* needed for BKE_group_object_exists() */
#include "BKE_object_deform.h"
#include "BKE_object_facemap.h"
#include "RNA_access.h"
#include "RNA_define.h"
@ -608,6 +609,87 @@ void rna_object_vgroup_name_set(PointerRNA *ptr, const char *value, char *result
result[0] = '\0';
}
static void rna_FaceMap_name_set(PointerRNA *ptr, const char *value)
{
Object *ob = (Object *)ptr->id.data;
bFaceMap *fmap = (bFaceMap *)ptr->data;
BLI_strncpy_utf8(fmap->name, value, sizeof(fmap->name));
BKE_object_facemap_unique_name(ob, fmap);
}
static int rna_FaceMap_index_get(PointerRNA *ptr)
{
Object *ob = (Object *)ptr->id.data;
return BLI_findindex(&ob->fmaps, ptr->data);
}
static PointerRNA rna_Object_active_face_map_get(PointerRNA *ptr)
{
Object *ob = (Object *)ptr->id.data;
return rna_pointer_inherit_refine(ptr, &RNA_FaceMap, BLI_findlink(&ob->fmaps, ob->actfmap - 1));
}
static int rna_Object_active_face_map_index_get(PointerRNA *ptr)
{
Object *ob = (Object *)ptr->id.data;
return ob->actfmap - 1;
}
static void rna_Object_active_face_map_index_set(PointerRNA *ptr, int value)
{
Object *ob = (Object *)ptr->id.data;
ob->actfmap = value + 1;
}
static void rna_Object_active_face_map_index_range(PointerRNA *ptr, int *min, int *max,
int *UNUSED(softmin), int *UNUSED(softmax))
{
Object *ob = (Object *)ptr->id.data;
*min = 0;
*max = max_ii(0, BLI_listbase_count(&ob->fmaps) - 1);
}
void rna_object_BKE_object_facemap_name_index_get(PointerRNA *ptr, char *value, int index)
{
Object *ob = (Object *)ptr->id.data;
bFaceMap *fmap;
fmap = BLI_findlink(&ob->fmaps, index - 1);
if (fmap) BLI_strncpy(value, fmap->name, sizeof(fmap->name));
else value[0] = '\0';
}
int rna_object_BKE_object_facemap_name_index_length(PointerRNA *ptr, int index)
{
Object *ob = (Object *)ptr->id.data;
bFaceMap *fmap;
fmap = BLI_findlink(&ob->fmaps, index - 1);
return (fmap) ? strlen(fmap->name) : 0;
}
void rna_object_BKE_object_facemap_name_index_set(PointerRNA *ptr, const char *value, short *index)
{
Object *ob = (Object *)ptr->id.data;
*index = BKE_object_facemap_name_index(ob, value) + 1;
}
void rna_object_fmap_name_set(PointerRNA *ptr, const char *value, char *result, int maxlen)
{
Object *ob = (Object *)ptr->id.data;
bFaceMap *fmap = BKE_object_facemap_find_name(ob, value);
if (fmap) {
BLI_strncpy(result, value, maxlen); /* no need for BLI_strncpy_utf8, since this matches an existing group */
return;
}
result[0] = '\0';
}
void rna_object_uvlayer_name_set(PointerRNA *ptr, const char *value, char *result, int maxlen)
{
Object *ob = (Object *)ptr->id.data;
@ -1452,6 +1534,69 @@ static float rna_VertexGroup_weight(ID *id, bDeformGroup *dg, ReportList *report
return weight;
}
static bFaceMap *rna_Object_fmap_new(Object *ob, const char *name)
{
bFaceMap *fmap = BKE_object_facemap_add_name(ob, name);
WM_main_add_notifier(NC_OBJECT | ND_DRAW, ob);
return fmap;
}
static void rna_Object_fmap_remove(Object *ob, ReportList *reports, PointerRNA *fmap_ptr)
{
bFaceMap *fmap = fmap_ptr->data;
if (BLI_findindex(&ob->fmaps, fmap) == -1) {
BKE_reportf(reports, RPT_ERROR, "FaceMap '%s' not in object '%s'", fmap->name, ob->id.name + 2);
return;
}
BKE_object_facemap_remove(ob, fmap);
RNA_POINTER_INVALIDATE(fmap_ptr);
WM_main_add_notifier(NC_OBJECT | ND_DRAW, ob);
}
static void rna_Object_fmap_clear(Object *ob)
{
BKE_object_facemap_clear(ob);
WM_main_add_notifier(NC_OBJECT | ND_DRAW, ob);
}
static void rna_FaceMap_face_add(ID *id, bFaceMap *fmap, ReportList *reports, int index_len,
int *index)
{
Object *ob = (Object *)id;
if (BKE_object_is_in_editmode(ob)) {
BKE_report(reports, RPT_ERROR, "FaceMap.add(): cannot be called while object is in edit mode");
return;
}
while (index_len--)
ED_object_facemap_face_add(ob, fmap, *index++);
WM_main_add_notifier(NC_GEOM | ND_DATA, (ID *)ob->data);
}
static void rna_FaceMap_face_remove(ID *id, bFaceMap *fmap, ReportList *reports, int index_len, int *index)
{
Object *ob = (Object *)id;
if (BKE_object_is_in_editmode(ob)) {
BKE_report(reports, RPT_ERROR, "FaceMap.add(): cannot be called while object is in edit mode");
return;
}
while (index_len--)
ED_object_facemap_face_remove(ob, fmap, *index++);
WM_main_add_notifier(NC_GEOM | ND_DATA, (ID *)ob->data);
}
/* generic poll functions */
int rna_Lattice_object_poll(PointerRNA *UNUSED(ptr), PointerRNA value)
{
@ -1571,6 +1716,44 @@ static void rna_def_vertex_group(BlenderRNA *brna)
RNA_def_function_return(func, parm);
}
static void rna_def_face_map(BlenderRNA *brna)
{
StructRNA *srna;
PropertyRNA *prop;
FunctionRNA *func;
srna = RNA_def_struct(brna, "FaceMap", NULL);
RNA_def_struct_sdna(srna, "bFaceMap");
RNA_def_struct_ui_text(srna, "Face Map", "Group of faces, each face can only be part of one map");
RNA_def_struct_ui_icon(srna, ICON_MOD_TRIANGULATE);
prop = RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
RNA_def_property_ui_text(prop, "Name", "Face map name");
RNA_def_struct_name_property(srna, prop);
RNA_def_property_string_funcs(prop, NULL, NULL, "rna_FaceMap_name_set");
/* update data because modifiers may use [#24761] */
RNA_def_property_update(prop, NC_GEOM | ND_DATA | NA_RENAME, "rna_Object_internal_update_data");
prop = RNA_def_property(srna, "index", PROP_INT, PROP_UNSIGNED);
RNA_def_property_clear_flag(prop, PROP_EDITABLE);
RNA_def_property_int_funcs(prop, "rna_FaceMap_index_get", NULL, NULL);
RNA_def_property_ui_text(prop, "Index", "Index number of the face map");
func = RNA_def_function(srna, "add", "rna_FaceMap_face_add");
RNA_def_function_ui_description(func, "Add vertices to the group");
RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
/* TODO, see how array size of 0 works, this shouldnt be used */
prop = RNA_def_int_array(func, "index", 1, NULL, 0, 0, "", "Index List", 0, 0);
RNA_def_parameter_flags(prop, PROP_DYNAMIC, PARM_REQUIRED);
func = RNA_def_function(srna, "remove", "rna_FaceMap_face_remove");
RNA_def_function_ui_description(func, "Remove a vertex from the group");
RNA_def_function_flag(func, FUNC_USE_REPORTS | FUNC_USE_SELF_ID);
/* TODO, see how array size of 0 works, this shouldnt be used */
prop = RNA_def_int_array(func, "index", 1, NULL, 0, 0, "", "Index List", 0, 0);
RNA_def_parameter_flags(prop, PROP_DYNAMIC, PARM_REQUIRED);
}
static void rna_def_material_slot(BlenderRNA *brna)
{
StructRNA *srna;
@ -2098,6 +2281,54 @@ static void rna_def_object_vertex_groups(BlenderRNA *brna, PropertyRNA *cprop)
RNA_def_function_ui_description(func, "Delete all vertex groups from object");
}
/* object.face_maps */
static void rna_def_object_face_maps(BlenderRNA *brna, PropertyRNA *cprop)
{
StructRNA *srna;
PropertyRNA *prop;
FunctionRNA *func;
PropertyRNA *parm;
RNA_def_property_srna(cprop, "FaceMaps");
srna = RNA_def_struct(brna, "FaceMaps", NULL);
RNA_def_struct_sdna(srna, "Object");
RNA_def_struct_ui_text(srna, "Face Maps", "Collection of face maps");
prop = RNA_def_property(srna, "active", PROP_POINTER, PROP_NONE);
RNA_def_property_struct_type(prop, "FaceMap");
RNA_def_property_pointer_funcs(prop, "rna_Object_active_face_map_get",
"rna_Object_active_face_map_set", NULL, NULL);
RNA_def_property_ui_text(prop, "Active Face Map", "Face maps of the object");
RNA_def_property_update(prop, NC_GEOM | ND_DATA, "rna_Object_internal_update_data");
prop = RNA_def_property(srna, "active_index", PROP_INT, PROP_UNSIGNED);
RNA_def_property_clear_flag(prop, PROP_ANIMATABLE);
RNA_def_property_int_sdna(prop, NULL, "actfmap");
RNA_def_property_int_funcs(prop, "rna_Object_active_face_map_index_get",
"rna_Object_active_face_map_index_set",
"rna_Object_active_face_map_index_range");
RNA_def_property_ui_text(prop, "Active Face Map Index", "Active index in face map array");
RNA_def_property_update(prop, NC_GEOM | ND_DATA, "rna_Object_internal_update_data");
/* face maps */ /* add_face_map */
func = RNA_def_function(srna, "new", "rna_Object_fmap_new");
RNA_def_function_ui_description(func, "Add face map to object");
RNA_def_string(func, "name", "Map", 0, "", "face map name"); /* optional */
parm = RNA_def_pointer(func, "fmap", "FaceMap", "", "New face map");
RNA_def_function_return(func, parm);
func = RNA_def_function(srna, "remove", "rna_Object_fmap_remove");
RNA_def_function_flag(func, FUNC_USE_REPORTS);
RNA_def_function_ui_description(func, "Delete vertex group from object");
parm = RNA_def_pointer(func, "group", "FaceMap", "", "Face map to remove");
RNA_def_parameter_flags(parm, PROP_NEVER_NULL, PARM_REQUIRED | PARM_RNAPTR);
RNA_def_property_clear_flag(parm, PROP_THICK_WRAP);
func = RNA_def_function(srna, "clear", "rna_Object_fmap_clear");
RNA_def_function_ui_description(func, "Delete all vertex groups from object");
}
static void rna_def_object_lodlevel(BlenderRNA *brna)
{
@ -2515,6 +2746,14 @@ static void rna_def_object(BlenderRNA *brna)
RNA_def_property_ui_text(prop, "Vertex Groups", "Vertex groups of the object");
rna_def_object_vertex_groups(brna, prop);
/* face maps */
prop = RNA_def_property(srna, "face_maps", PROP_COLLECTION, PROP_NONE);
RNA_def_property_collection_sdna(prop, NULL, "fmaps", NULL);
RNA_def_property_struct_type(prop, "FaceMap");
RNA_def_property_ui_text(prop, "Face Maps", "Maps of faces of the object");
rna_def_object_face_maps(brna, prop);
/* empty */
prop = RNA_def_property(srna, "empty_draw_type", PROP_ENUM, PROP_NONE);
RNA_def_property_enum_sdna(prop, NULL, "empty_drawtype");
@ -2935,6 +3174,7 @@ void RNA_def_object(BlenderRNA *brna)
rna_def_object_game_settings(brna);
rna_def_object_base_legacy(brna);
rna_def_vertex_group(brna);
rna_def_face_map(brna);
rna_def_material_slot(brna);
rna_def_dupli_object(brna);
RNA_define_animate_sdna(true);