void DebugLine::add_unit(ResourceManager& rm, const Matrix4x4& tm, StringId64 name, const Color4& color)
{
const UnitResource& ur = *(const UnitResource*)rm.get(RESOURCE_TYPE_UNIT, name);
const char* component_data = (const char*)(&ur + 1);
for (u32 cc = 0; cc < ur.num_component_types; ++cc)
{
const ComponentData* component = (const ComponentData*)component_data;
const u32* unit_index = (const u32*)(component + 1);
const char* data = (const char*)(unit_index + component->num_instances);
if (component->type == COMPONENT_TYPE_MESH_RENDERER)
{
const MeshRendererDesc* mrd = (const MeshRendererDesc*)data;
for (u32 i = 0; i < component->num_instances; ++i, ++mrd)
{
const MeshResource* mr = (const MeshResource*)rm.get(RESOURCE_TYPE_MESH, mrd->mesh_resource);
const MeshGeometry* mg = mr->geometry(mrd->geometry_name);
add_mesh(tm
, mg->vertices.data
, mg->vertices.stride
, (u16*)mg->indices.data
, mg->indices.num
, color
);
}
}
component_data += component->size + sizeof(ComponentData);
}
}
static Object *AddNewBlenderMesh(Scene *scene, Base *base)
{
// This little function adds a new mesh object to the blender object list
// It uses ob to duplicate data as this seems to be easier than creating
// a new one. This new oject contains no faces nor vertices.
Mesh *old_me;
Base *basen;
Object *ob_new;
// now create a new blender object.
// duplicating all the settings from the previous object
// to the new one.
ob_new= copy_object(base->object);
// Ok we don't want to use the actual data from the
// last object, the above function incremented the
// number of users, so decrement it here.
old_me= ob_new->data;
old_me->id.us--;
// Now create a new base to add into the linked list of
// vase objects.
basen= MEM_mallocN(sizeof(Base), "duplibase");
*basen= *base;
BLI_addhead(&scene->base, basen); /* addhead: anders oneindige lus */
basen->object= ob_new;
basen->flag &= ~SELECT;
// Initialize the mesh data associated with this object.
ob_new->data= add_mesh("Mesh");
// Finally assign the object type.
ob_new->type= OB_MESH;
return ob_new;
}
Mesh *rna_Main_meshes_new(Main *UNUSED(bmain), const char *name)
{
Mesh *me= add_mesh(name);
id_us_min(&me->id);
return me;
}
/* return 1: success */
static int mesh_separate_selected(wmOperator *op, Main *bmain, Scene *scene, Base *editbase)
{
EditMesh *em, *emnew;
EditVert *eve, *v1;
EditEdge *eed, *e1;
EditFace *efa, *f1;
Object *obedit;
Mesh *me, *menew;
Base *basenew;
if(editbase==NULL) return 0;
obedit= editbase->object;
me= obedit->data;
em= BKE_mesh_get_editmesh(me);
if(me->key) {
BKE_report(op->reports, RPT_WARNING, "Can't separate mesh with shape keys");
BKE_mesh_end_editmesh(me, em);
return 0;
}
if(em->selected.first)
BLI_freelistN(&(em->selected)); /* clear the selection order */
EM_selectmode_set(em); // enforce full consistent selection flags
EM_stats_update(em);
if(em->totvertsel==0) {
BKE_mesh_end_editmesh(me, em);
return 0;
}
/* we are going to work as follows:
* 1. add a linked duplicate object: this will be the new one, we remember old pointer
* 2. give new object empty mesh and put in editmode
* 3: do a split if needed on current editmesh.
* 4. copy over: all NOT selected verts, edges, faces
* 5. call load_editMesh() on the new object
*/
/* 1 */
basenew= ED_object_add_duplicate(bmain, scene, editbase, 0); /* 0 = fully linked */
ED_base_object_select(basenew, BA_DESELECT);
/* 2 */
basenew->object->data= menew= add_mesh(me->id.name+2); /* empty */
assign_matarar(basenew->object, give_matarar(obedit), *give_totcolp(obedit)); /* new in 2.5 */
me->id.us--;
make_editMesh(scene, basenew->object);
emnew= menew->edit_mesh;
CustomData_copy(&em->vdata, &emnew->vdata, CD_MASK_EDITMESH, CD_DEFAULT, 0);
CustomData_copy(&em->edata, &emnew->edata, CD_MASK_EDITMESH, CD_DEFAULT, 0);
CustomData_copy(&em->fdata, &emnew->fdata, CD_MASK_EDITMESH, CD_DEFAULT, 0);
/* 3 */
/* SPLIT: first make duplicate */
adduplicateflag(em, SELECT);
/* SPLIT: old faces have 3x flag 128 set, delete these ones */
delfaceflag(em, 128);
/* since we do tricky things with verts/edges/faces, this makes sure all is selected coherent */
EM_selectmode_set(em);
/* 4 */
/* move over: everything that is selected */
for(eve= em->verts.first; eve; eve= v1) {
v1= eve->next;
if(eve->f & SELECT) {
BLI_remlink(&em->verts, eve);
BLI_addtail(&emnew->verts, eve);
}
}
for(eed= em->edges.first; eed; eed= e1) {
e1= eed->next;
if(eed->f & SELECT) {
BLI_remlink(&em->edges, eed);
BLI_addtail(&emnew->edges, eed);
}
}
for(efa= em->faces.first; efa; efa= f1) {
f1= efa->next;
if (efa == em->act_face && (efa->f & SELECT)) {
EM_set_actFace(em, NULL);
}
if(efa->f & SELECT) {
BLI_remlink(&em->faces, efa);
BLI_addtail(&emnew->faces, efa);
}
}
/* 5 */
load_editMesh(scene, basenew->object);
free_editMesh(emnew);
MEM_freeN(menew->edit_mesh);
menew->edit_mesh= NULL;
/* copy settings */
menew->texflag= me->texflag;
menew->drawflag= me->drawflag;
menew->flag= me->flag;
menew->editflag= me->editflag;
menew->smoothresh= me->smoothresh;
/* hashedges are invalid now, make new! */
editMesh_set_hash(em);
DAG_id_tag_update(&obedit->id, OB_RECALC_DATA);
DAG_id_tag_update(&basenew->object->id, OB_RECALC_DATA);
BKE_mesh_end_editmesh(me, em);
return 1;
}
/* settings: 0 - preview, 1 - render */
Mesh *rna_Object_to_mesh(Object *ob, ReportList *reports, Scene *sce, int apply_modifiers, int settings)
{
Mesh *tmpmesh;
Curve *tmpcu = NULL;
Object *tmpobj = NULL;
int render = settings == eModifierMode_Render, i;
int cage = !apply_modifiers;
/* perform the mesh extraction based on type */
switch (ob->type) {
case OB_FONT:
case OB_CURVE:
case OB_SURF:
/* copies object and modifiers (but not the data) */
tmpobj= copy_object(ob);
tmpcu = (Curve *)tmpobj->data;
tmpcu->id.us--;
/* if getting the original caged mesh, delete object modifiers */
if( cage )
object_free_modifiers(tmpobj);
/* copies the data */
tmpobj->data = copy_curve( (Curve *) ob->data );
#if 0
/* copy_curve() sets disp.first null, so currently not need */
{
Curve *cu;
cu = (Curve *)tmpobj->data;
if( cu->disp.first )
MEM_freeN( cu->disp.first );
cu->disp.first = NULL;
}
#endif
/* get updated display list, and convert to a mesh */
makeDispListCurveTypes( sce, tmpobj, 0 );
nurbs_to_mesh( tmpobj );
/* nurbs_to_mesh changes the type to a mesh, check it worked */
if (tmpobj->type != OB_MESH) {
free_libblock_us( &(G.main->object), tmpobj );
BKE_report(reports, RPT_ERROR, "cant convert curve to mesh. Does the curve have any segments?");
return NULL;
}
tmpmesh = tmpobj->data;
free_libblock_us( &G.main->object, tmpobj );
break;
case OB_MBALL: {
/* metaballs don't have modifiers, so just convert to mesh */
Object *basis_ob = find_basis_mball(sce, ob);
/* todo, re-generatre for render-res */
/* metaball_polygonize(scene, ob) */
if(ob != basis_ob)
return NULL; /* only do basis metaball */
tmpmesh = add_mesh("Mesh");
if(render) {
ListBase disp = {NULL, NULL};
makeDispListMBall_forRender(sce, ob, &disp);
mball_to_mesh(&disp, tmpmesh);
freedisplist(&disp);
}
else
mball_to_mesh(&ob->disp, tmpmesh);
break;
}
case OB_MESH:
/* copies object and modifiers (but not the data) */
if (cage) {
/* copies the data */
tmpmesh = copy_mesh( ob->data );
/* if not getting the original caged mesh, get final derived mesh */
} else {
/* Make a dummy mesh, saves copying */
DerivedMesh *dm;
/* CustomDataMask mask = CD_MASK_BAREMESH|CD_MASK_MTFACE|CD_MASK_MCOL; */
CustomDataMask mask = CD_MASK_MESH; /* this seems more suitable, exporter,
for example, needs CD_MASK_MDEFORMVERT */
/* Write the display mesh into the dummy mesh */
if (render)
dm = mesh_create_derived_render( sce, ob, mask );
else
dm = mesh_create_derived_view( sce, ob, mask );
tmpmesh = add_mesh( "Mesh" );
DM_to_mesh( dm, tmpmesh );
dm->release( dm );
}
break;
default:
BKE_report(reports, RPT_ERROR, "Object does not have geometry data");
return NULL;
}
/* Copy materials to new mesh */
switch (ob->type) {
case OB_SURF:
case OB_FONT:
case OB_CURVE:
tmpmesh->totcol = tmpcu->totcol;
/* free old material list (if it exists) and adjust user counts */
if( tmpcu->mat ) {
for( i = tmpcu->totcol; i-- > 0; ) {
/* are we an object material or data based? */
tmpmesh->mat[i] = ob->matbits[i] ? ob->mat[i] : tmpcu->mat[i];
if (tmpmesh->mat[i]) {
tmpmesh->mat[i]->id.us++;
}
}
}
break;
#if 0
/* Crashes when assigning the new material, not sure why */
case OB_MBALL:
tmpmb = (MetaBall *)ob->data;
tmpmesh->totcol = tmpmb->totcol;
/* free old material list (if it exists) and adjust user counts */
if( tmpmb->mat ) {
for( i = tmpmb->totcol; i-- > 0; ) {
tmpmesh->mat[i] = tmpmb->mat[i]; /* CRASH HERE ??? */
if (tmpmesh->mat[i]) {
tmpmb->mat[i]->id.us++;
}
}
}
break;
#endif
case OB_MESH:
if (!cage) {
Mesh *origmesh= ob->data;
tmpmesh->flag= origmesh->flag;
tmpmesh->mat = MEM_dupallocN(origmesh->mat);
tmpmesh->totcol = origmesh->totcol;
tmpmesh->smoothresh= origmesh->smoothresh;
if( origmesh->mat ) {
for( i = origmesh->totcol; i-- > 0; ) {
/* are we an object material or data based? */
tmpmesh->mat[i] = ob->matbits[i] ? ob->mat[i] : origmesh->mat[i];
if (tmpmesh->mat[i]) {
tmpmesh->mat[i]->id.us++;
}
}
}
}
break;
} /* end copy materials */
/* we don't assign it to anything */
tmpmesh->id.us--;
/* make sure materials get updated in objects */
test_object_materials( ( ID * ) tmpmesh );
return tmpmesh;
}
