Page MenuHome
Differential D817 Diff 2694 source/blender/blenloader/intern/readfile.c

Changeset View

Standalone View

View Options

source/blender/blenloader/intern/readfile.c

Context not available.
#include "DNA_dynamicpaint_types.h" #include "DNA_dynamicpaint_types.h"
#include "DNA_effect_types.h" #include "DNA_effect_types.h"
#include "DNA_fileglobal_types.h" #include "DNA_fileglobal_types.h"
#include "DNA_fracture_types.h"
#include "DNA_genfile.h" #include "DNA_genfile.h"
#include "DNA_group_types.h" #include "DNA_group_types.h"
#include "DNA_gpencil_types.h" #include "DNA_gpencil_types.h"
Context not available.
#include "BKE_depsgraph.h" #include "BKE_depsgraph.h"
#include "BKE_effect.h" #include "BKE_effect.h"
#include "BKE_fcurve.h" #include "BKE_fcurve.h"
#include "BKE_fracture.h"
#include "BKE_global.h" // for G #include "BKE_global.h" // for G
#include "BKE_group.h" #include "BKE_group.h"
#include "BKE_library.h" // for which_libbase #include "BKE_library.h" // for which_libbase
Context not available.
#include <errno.h> #include <errno.h>
#include "BKE_cdderivedmesh.h" //for fracture meshisland handling
sergeyUnsubmitted
Not Done
Inline Actions

This must not be needed. DerivedMesh is totally volatile, being created only when it's needed in the scene update routines. No DM operations should happen on read/write.

sergey: This must not be needed. DerivedMesh is totally volatile, being created only when it's needed…
/* /*
* Remark: still a weak point is the newaddress() function, that doesnt solve reading from * Remark: still a weak point is the newaddress() function, that doesnt solve reading from
* multiple files at the same time * multiple files at the same time
Context not available.
} }
} }
/* used with fracture modifier */
static void direct_link_customdata_fracture(FileData *fd, CustomData *data, int count)
{
/*need to load the dverts here for fracture, so handle this in a special function, normally
*the dverts arent loaded here, for what reason ever.... */
int i = 0;
data->layers = newdataadr(fd, data->layers);
/* annoying workaround for bug [#31079] loading legacy files with
* no polygons _but_ have stale customdata */
if (UNLIKELY(count == 0 && data->layers == NULL && data->totlayer != 0)) {
CustomData_reset(data);
return;
}
data->external = newdataadr(fd, data->external);
while (i < data->totlayer) {
CustomDataLayer *layer = &data->layers[i];
if (layer->flag & CD_FLAG_EXTERNAL)
layer->flag &= ~CD_FLAG_IN_MEMORY;
layer->flag &= ~CD_FLAG_NOFREE;
if (CustomData_verify_versions(data, i)) {
layer->data = newdataadr(fd, layer->data);
if (layer->type == CD_MDISPS)
direct_link_mdisps(fd, count, layer->data, layer->flag & CD_FLAG_EXTERNAL);
else if (layer->type == CD_GRID_PAINT_MASK)
direct_link_grid_paint_mask(fd, count, layer->data);
else if (layer->type == CD_MDEFORMVERT) {
/* layer types that allocate own memory need special handling */
direct_link_dverts(fd, count, layer->data);
}
i++;
}
}
CustomData_update_typemap(data);
}
/*this isn't really a public api function, so prototyped here*/ /*this isn't really a public api function, so prototyped here*/
static void direct_link_customdata(FileData *fd, CustomData *data, int count) static void direct_link_customdata(FileData *fd, CustomData *data, int count)
{ {
Context not available.
direct_link_mdisps(fd, count, layer->data, layer->flag & CD_FLAG_EXTERNAL); direct_link_mdisps(fd, count, layer->data, layer->flag & CD_FLAG_EXTERNAL);
else if (layer->type == CD_GRID_PAINT_MASK) else if (layer->type == CD_GRID_PAINT_MASK)
direct_link_grid_paint_mask(fd, count, layer->data); direct_link_grid_paint_mask(fd, count, layer->data);
i++; i++;
} }
} }
Context not available.
} }
} }
/* used with fracture modifier*/
void direct_link_customdata_mtpoly_shard(FileData *fd, CustomData *pdata, int totface);
void direct_link_customdata_mtpoly_shard(FileData *fd, CustomData *pdata, int totface)
{
int i;
for (i=0; i < pdata->totlayer; i++) {
CustomDataLayer *layer = &pdata->layers[i];
if (layer->type == CD_MTEXPOLY) {
MTexPoly *tf= layer->data;
int j;
for (j = 0; j < totface; j++, tf++) {
tf->tpage = newdataadr(fd, tf->tpage);
if (tf->tpage && tf->tpage->id.us == 0) {
tf->tpage->id.us = 1;
}
}
}
}
}
static void read_shard(FileData *fd, Shard **address )
{
Shard* s = *address;
s->mvert = newdataadr(fd, s->mvert);
s->mpoly = newdataadr(fd, s->mpoly);
s->mloop = newdataadr(fd, s->mloop);
direct_link_customdata_fracture(fd, &s->vertData, s->totvert);
direct_link_customdata_fracture(fd, &s->loopData, s->totloop);
direct_link_customdata_fracture(fd, &s->polyData, s->totpoly);
s->neighbor_ids = newdataadr(fd, s->neighbor_ids);
s->cluster_colors = newdataadr(fd, s->cluster_colors);
}
static void read_meshIsland(FileData *fd, MeshIsland **address)
{
MeshIsland* mi;
mi = *address;
mi->vertices = NULL;
mi->vertices_cached = NULL;
mi->vertco = newdataadr(fd, mi->vertco);
mi->temp = newdataadr(fd, mi->temp);
read_shard(fd, &(mi->temp));
mi->physics_mesh = BKE_shard_create_dm(mi->temp, true);
BKE_shard_free(mi->temp, true);
mi->temp = NULL;
mi->vertno = newdataadr(fd, mi->vertno);
mi->rigidbody = newdataadr(fd, mi->rigidbody);
mi->rigidbody->physics_object = newdataadr(fd, mi->rigidbody->physics_object);
mi->rigidbody->physics_shape = newdataadr(fd, mi->rigidbody->physics_shape);
mi->rigidbody->flag |= RBO_FLAG_NEEDS_VALIDATE;
mi->rigidbody->flag |= RBO_FLAG_NEEDS_RESHAPE;
mi->neighbor_ids = newdataadr(fd, mi->neighbor_ids );
mi->bb = newdataadr(fd, mi->bb);
mi->vertex_indices = newdataadr(fd, mi->vertex_indices);
/* will be refreshed on the fly */
mi->participating_constraint_count = 0;
mi->participating_constraints = NULL;
}
static void direct_link_modifiers(FileData *fd, ListBase *lb) static void direct_link_modifiers(FileData *fd, ListBase *lb)
{ {
ModifierData *md; ModifierData *md;
Context not available.
} }
lmd->cache_system = NULL; lmd->cache_system = NULL;
} }
else if (md->type == eModifierType_Fracture) {
int i = 0;
FractureModifierData *fmd = (FractureModifierData *)md;
FracMesh* fm;
fm = fmd->frac_mesh = newdataadr(fd, fmd->frac_mesh);
fmd->refresh = false; /* do not execute modifier here yet*/
fmd->refresh_constraints = false;
fmd->nor_tree = NULL;
fmd->face_pairs = NULL;
if (fm == NULL) {
fmd->dm = NULL;
fmd->meshIslands.first = NULL;
fmd->meshIslands.last = NULL;
fmd->visible_mesh = NULL;
fmd->visible_mesh_cached = NULL;
zero_m4(fmd->origmat);
fmd->meshConstraints.first = NULL;
fmd->meshConstraints.last = NULL;
fmd->explo_shared = false;
fmd->refresh = false; /* do not execute modifier */
fmd->refresh_constraints = false;
fmd->max_vol = 0;
fmd->refresh_images = false;
}
else {
MeshIsland *mi;
MVert *mverts;
int vertstart = 0;
Shard *s;
int count = 0;
fm->shard_map = newdataadr(fd, fm->shard_map);
for (i = 0; i < fm->shard_count; i++) {
fm->shard_map[i] = newdataadr(fd, fm->shard_map[i]);
read_shard(fd, &(fm->shard_map[i]));
}
fmd->frac_mesh = fm;
fmd->dm = NULL;
fmd->visible_mesh = NULL;
link_list(fd, &fmd->islandShards);
for (s = fmd->islandShards.first; s; s = s->next) {
read_shard(fd, &s);
}
link_list(fd, &fmd->meshIslands);
count = BLI_countlist(&fmd->islandShards);
if ((fmd->islandShards.first == NULL || count == 0) && fm->shard_count > 0) {
/* oops, a refresh was missing, so disable this flag here better, otherwise
* we attempt to load non existing data */
fmd->shards_to_islands = false;
}
else if (fm->shard_count == 0) {
fmd->shards_to_islands = true;
}
/* ugly ugly, need only the shard... the rest is to be generated on demand... */
BKE_fracture_create_dm(fmd, true);
if (fm->shard_count == 0) {
fmd->shards_to_islands = false;
}
fmd->visible_mesh_cached = CDDM_copy(fmd->dm);
if (fmd->visible_mesh == NULL) {
fmd->visible_mesh = DM_to_bmesh(fmd->visible_mesh_cached, true);
}
DM_ensure_tessface(fmd->visible_mesh_cached);
DM_ensure_normals(fmd->visible_mesh_cached);
DM_update_tessface_data(fmd->visible_mesh_cached);
/* re-init cached verts here... */
mverts = CDDM_get_verts(fmd->visible_mesh_cached);
for (mi = fmd->meshIslands.first; mi; mi = mi->next) {
int k = 0;
read_meshIsland(fd, &mi);
mi->vertices_cached = MEM_mallocN(sizeof(MVert*) * mi->vertex_count, "mi->vertices_cached readfile");
for (k = 0; k < mi->vertex_count; k++) {
MVert* v = mverts + vertstart + k ;
mi->vertices_cached[k] = v;
mi->vertco[k*3] = v->co[0];
mi->vertco[k*3+1] = v->co[1];
mi->vertco[k*3+2] = v->co[2];
if (mi->vertno != NULL && fmd->fix_normals) {
float no[3];
short sno[3];
no[0] = mi->vertno[k*3];
no[1] = mi->vertno[k*3+1];
no[2] = mi->vertno[k*3+2];
normal_float_to_short_v3(sno, no);
copy_v3_v3_short(mi->vertices_cached[k]->no, sno);
}
}
vertstart += mi->vertex_count;
}
fmd->refresh_constraints = true;
fmd->meshConstraints.first = NULL;
fmd->meshConstraints.last = NULL;
fmd->refresh_images = true;
}
}
} }
} }
Context not available.
rbw->physics_world = NULL; rbw->physics_world = NULL;
rbw->objects = NULL; rbw->objects = NULL;
rbw->numbodies = 0; rbw->numbodies = 0;
rbw->cache_index_map = NULL;
rbw->cache_offset_map = NULL;
/* set effector weights */ /* set effector weights */
rbw->effector_weights = newdataadr(fd, rbw->effector_weights); rbw->effector_weights = newdataadr(fd, rbw->effector_weights);
Context not available.
rv3d->depths = NULL; rv3d->depths = NULL;
rv3d->gpuoffscreen = NULL; rv3d->gpuoffscreen = NULL;
rv3d->ri = NULL;
rv3d->render_engine = NULL; rv3d->render_engine = NULL;
rv3d->sms = NULL; rv3d->sms = NULL;
rv3d->smooth_timer = NULL; rv3d->smooth_timer = NULL;
Context not available.
direct_link_paint_curve(fd, (PaintCurve *)id); direct_link_paint_curve(fd, (PaintCurve *)id);
break; break;
} }
oldnewmap_free_unused(fd->datamap); oldnewmap_free_unused(fd->datamap);
oldnewmap_clear(fd->datamap); oldnewmap_clear(fd->datamap);
Context not available.