Janne Karhu
874d38eeb4
- Baked point caches for particles, cloth and softbody can now be edited in particle mode. * This overwrites the old cloth/sb cache editmode editing. * The type of editable system is chosen from a menu. * For particles the current particle system and it's current cache are used. - Currently this only works for caches that are in memory, but some automatic conversion from disk to memory and back can be implemented later. - All tools from hair editing can't be applied to point caches and are hidden in the tool panel and specials menu. Some functionality like subdividing paths can be later implemented in a slightly different way from how it works for hair. - Code is not yet optimized for speed, so editing might be slow sometimes. Known issues: - Cloth doesn't update properly while in particle mode, due to the way cloth modifier currently works. Daniel can you check on this? - As "particle mode" is not only for particles any more some other name would be in place? - Better icons are needed for the path, point, and tip-modes as the current icons from mesh edit mode are quite misleading. - Direct editing of point velocities is not yet implemented, but will be in the future. Other changes: - Hair editing doesn't require a "make editable" button press any more. - Multiple caches in single particle system disables changing emission properties. - Unified ui code for all point cache panels. * Defined in buttons_particle.py and imported for cloth, smoke & softbody. - Proper disabling of properties in ui after baking point caches. (Daniel could you please make needed disable code for smoke panels as their functionality is not familiar to me.) - Hair weight brush has been removed. Once hair dynamics is re-implemented I'll code a more useable alternative to the functionality. Bug fixes: - Unlinking particle settings crashed. - Deleting the active object with particles in the scene crashed. - Softbody didn't write point caches correctly on save.
2533 lines
64 KiB
C
2533 lines
64 KiB
C
/**
|
|
*
|
|
* ***** 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*
|
|
* The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
|
|
* All rights reserved.
|
|
*
|
|
* Contributor(s): Campbell Barton <ideasman42@gmail.com>
|
|
*
|
|
* ***** END GPL LICENSE BLOCK *****
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
|
|
#include "MEM_guardedalloc.h"
|
|
|
|
#include "DNA_ID.h"
|
|
#include "DNA_cloth_types.h"
|
|
#include "DNA_modifier_types.h"
|
|
#include "DNA_object_types.h"
|
|
#include "DNA_object_force.h"
|
|
#include "DNA_particle_types.h"
|
|
#include "DNA_scene_types.h"
|
|
#include "DNA_smoke_types.h"
|
|
|
|
#include "BLI_blenlib.h"
|
|
|
|
#include "BKE_cloth.h"
|
|
#include "BKE_depsgraph.h"
|
|
#include "BKE_global.h"
|
|
#include "BKE_library.h"
|
|
#include "BKE_main.h"
|
|
#include "BKE_modifier.h"
|
|
#include "BKE_object.h"
|
|
#include "BKE_particle.h"
|
|
#include "BKE_pointcache.h"
|
|
#include "BKE_scene.h"
|
|
#include "BKE_smoke.h"
|
|
#include "BKE_softbody.h"
|
|
#include "BKE_utildefines.h"
|
|
|
|
#include "BLI_blenlib.h"
|
|
|
|
/* both in intern */
|
|
#include "smoke_API.h"
|
|
#include "minilzo.h"
|
|
|
|
#include "LzmaLib.h"
|
|
|
|
|
|
/* needed for directory lookup */
|
|
#ifndef WIN32
|
|
#include <dirent.h>
|
|
#else
|
|
#include "BLI_winstuff.h"
|
|
#endif
|
|
|
|
/* untitled blend's need getpid for a unique name */
|
|
#ifdef WIN32
|
|
#include <process.h>
|
|
#else
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
#ifdef _WIN32
|
|
#ifndef snprintf
|
|
#define snprintf _snprintf
|
|
#endif
|
|
#endif
|
|
|
|
static void ptcache_data_to(void **data, int type, int index, void *to);
|
|
static void ptcache_data_from(void **data, int type, void *from);
|
|
|
|
/* Common functions */
|
|
static int ptcache_read_basic_header(PTCacheFile *pf)
|
|
{
|
|
int error=0;
|
|
|
|
/* Custom functions should read these basic elements too! */
|
|
if(!error && !fread(&pf->totpoint, sizeof(int), 1, pf->fp))
|
|
error = 1;
|
|
|
|
if(!error && !fread(&pf->data_types, sizeof(int), 1, pf->fp))
|
|
error = 1;
|
|
|
|
return !error;
|
|
}
|
|
static int ptcache_write_basic_header(PTCacheFile *pf)
|
|
{
|
|
/* Custom functions should write these basic elements too! */
|
|
if(!fwrite(&pf->totpoint, sizeof(int), 1, pf->fp))
|
|
return 0;
|
|
|
|
if(!fwrite(&pf->data_types, sizeof(int), 1, pf->fp))
|
|
return 0;
|
|
|
|
return 1;
|
|
}
|
|
/* Softbody functions */
|
|
static int ptcache_write_softbody(int index, void *soft_v, void **data)
|
|
{
|
|
SoftBody *soft= soft_v;
|
|
BodyPoint *bp = soft->bpoint + index;
|
|
|
|
ptcache_data_from(data, BPHYS_DATA_LOCATION, bp->pos);
|
|
ptcache_data_from(data, BPHYS_DATA_VELOCITY, bp->vec);
|
|
|
|
return 1;
|
|
}
|
|
static void ptcache_read_softbody(int index, void *soft_v, void **data, float frs_sec, float cfra, float *old_data)
|
|
{
|
|
SoftBody *soft= soft_v;
|
|
BodyPoint *bp = soft->bpoint + index;
|
|
|
|
if(old_data) {
|
|
memcpy(bp->pos, data, 3 * sizeof(float));
|
|
memcpy(bp->vec, data + 3, 3 * sizeof(float));
|
|
}
|
|
else {
|
|
ptcache_data_to(data, BPHYS_DATA_LOCATION, 0, bp->pos);
|
|
ptcache_data_to(data, BPHYS_DATA_VELOCITY, 0, bp->vec);
|
|
}
|
|
}
|
|
static void ptcache_interpolate_softbody(int index, void *soft_v, void **data, float frs_sec, float cfra, float cfra1, float cfra2, float *old_data)
|
|
{
|
|
SoftBody *soft= soft_v;
|
|
BodyPoint *bp = soft->bpoint + index;
|
|
ParticleKey keys[4];
|
|
float dfra;
|
|
|
|
if(cfra1 == cfra2)
|
|
return;
|
|
|
|
VECCOPY(keys[1].co, bp->pos);
|
|
VECCOPY(keys[1].vel, bp->vec);
|
|
|
|
if(old_data) {
|
|
memcpy(keys[2].co, old_data, 3 * sizeof(float));
|
|
memcpy(keys[2].vel, old_data + 3, 3 * sizeof(float));
|
|
}
|
|
else
|
|
BKE_ptcache_make_particle_key(keys+2, 0, data, cfra2);
|
|
|
|
dfra = cfra2 - cfra1;
|
|
|
|
VecMulf(keys[1].vel, dfra);
|
|
VecMulf(keys[2].vel, dfra);
|
|
|
|
psys_interpolate_particle(-1, keys, (cfra - cfra1) / dfra, keys, 1);
|
|
|
|
VecMulf(keys->vel, 1.0f / dfra);
|
|
|
|
VECCOPY(bp->pos, keys->co);
|
|
VECCOPY(bp->vec, keys->vel);
|
|
}
|
|
static int ptcache_totpoint_softbody(void *soft_v)
|
|
{
|
|
SoftBody *soft= soft_v;
|
|
return soft->totpoint;
|
|
}
|
|
/* Particle functions */
|
|
static int ptcache_write_particle(int index, void *psys_v, void **data)
|
|
{
|
|
ParticleSystem *psys= psys_v;
|
|
ParticleData *pa = psys->particles + index;
|
|
float times[3] = {pa->time, pa->dietime, pa->lifetime};
|
|
|
|
if(data[BPHYS_DATA_INDEX]) {
|
|
int step = psys->pointcache->step;
|
|
/* No need to store unborn or died particles */
|
|
if(pa->time - step > pa->state.time || pa->dietime + step < pa->state.time)
|
|
return 0;
|
|
}
|
|
|
|
ptcache_data_from(data, BPHYS_DATA_INDEX, &index);
|
|
ptcache_data_from(data, BPHYS_DATA_LOCATION, pa->state.co);
|
|
ptcache_data_from(data, BPHYS_DATA_VELOCITY, pa->state.vel);
|
|
ptcache_data_from(data, BPHYS_DATA_ROTATION, pa->state.rot);
|
|
ptcache_data_from(data, BPHYS_DATA_AVELOCITY, pa->state.ave);
|
|
ptcache_data_from(data, BPHYS_DATA_SIZE, &pa->size);
|
|
ptcache_data_from(data, BPHYS_DATA_TIMES, times);
|
|
|
|
if(pa->boid)
|
|
ptcache_data_from(data, BPHYS_DATA_TIMES, &pa->boid);
|
|
|
|
return 1;
|
|
}
|
|
void BKE_ptcache_make_particle_key(ParticleKey *key, int index, void **data, float time)
|
|
{
|
|
ptcache_data_to(data, BPHYS_DATA_LOCATION, index, key->co);
|
|
ptcache_data_to(data, BPHYS_DATA_VELOCITY, index, key->vel);
|
|
ptcache_data_to(data, BPHYS_DATA_ROTATION, index, key->rot);
|
|
ptcache_data_to(data, BPHYS_DATA_AVELOCITY, index, key->ave);
|
|
key->time = time;
|
|
}
|
|
static void ptcache_read_particle(int index, void *psys_v, void **data, float frs_sec, float cfra, float *old_data)
|
|
{
|
|
ParticleSystem *psys= psys_v;
|
|
ParticleData *pa = psys->particles + index;
|
|
|
|
if(cfra > pa->state.time)
|
|
memcpy(&pa->prev_state, &pa->state, sizeof(ParticleKey));
|
|
|
|
if(old_data){
|
|
/* old format cache */
|
|
memcpy(&pa->state, old_data, sizeof(ParticleKey));
|
|
return;
|
|
}
|
|
|
|
BKE_ptcache_make_particle_key(&pa->state, 0, data, cfra);
|
|
|
|
if(data[BPHYS_DATA_SIZE])
|
|
ptcache_data_to(data, BPHYS_DATA_SIZE, 0, &pa->size);
|
|
|
|
if(data[BPHYS_DATA_TIMES]) {
|
|
float times[3];
|
|
ptcache_data_to(data, BPHYS_DATA_TIMES, 0, ×);
|
|
pa->time = times[0];
|
|
pa->dietime = times[1];
|
|
pa->lifetime = times[2];
|
|
}
|
|
|
|
if(pa->boid)
|
|
ptcache_data_to(data, BPHYS_DATA_BOIDS, 0, &pa->boid);
|
|
|
|
/* determine velocity from previous location */
|
|
if(data[BPHYS_DATA_LOCATION] && !data[BPHYS_DATA_VELOCITY]) {
|
|
if(cfra > pa->prev_state.time) {
|
|
VecSubf(pa->state.vel, pa->state.co, pa->prev_state.co);
|
|
VecMulf(pa->state.vel, (cfra - pa->prev_state.time) / frs_sec);
|
|
}
|
|
else {
|
|
VecSubf(pa->state.vel, pa->prev_state.co, pa->state.co);
|
|
VecMulf(pa->state.vel, (pa->prev_state.time - cfra) / frs_sec);
|
|
}
|
|
}
|
|
|
|
/* determine rotation from velocity */
|
|
if(data[BPHYS_DATA_LOCATION] && !data[BPHYS_DATA_ROTATION]) {
|
|
vectoquat(pa->state.vel, OB_POSX, OB_POSZ, pa->state.rot);
|
|
}
|
|
}
|
|
static void ptcache_interpolate_particle(int index, void *psys_v, void **data, float frs_sec, float cfra, float cfra1, float cfra2, float *old_data)
|
|
{
|
|
ParticleSystem *psys= psys_v;
|
|
ParticleData *pa = psys->particles + index;
|
|
ParticleKey keys[4];
|
|
float dfra;
|
|
|
|
cfra = MIN2(cfra, pa->dietime);
|
|
cfra1 = MIN2(cfra1, pa->dietime);
|
|
cfra2 = MIN2(cfra2, pa->dietime);
|
|
|
|
if(cfra1 == cfra2)
|
|
return;
|
|
|
|
memcpy(keys+1, &pa->state, sizeof(ParticleKey));
|
|
if(old_data)
|
|
memcpy(keys+2, old_data, sizeof(ParticleKey));
|
|
else
|
|
BKE_ptcache_make_particle_key(keys+2, 0, data, cfra2);
|
|
|
|
dfra = cfra2 - cfra1;
|
|
|
|
VecMulf(keys[1].vel, dfra / frs_sec);
|
|
VecMulf(keys[2].vel, dfra / frs_sec);
|
|
|
|
psys_interpolate_particle(-1, keys, (cfra - cfra1) / dfra, &pa->state, 1);
|
|
QuatInterpol(pa->state.rot, keys[1].rot,keys[2].rot, (cfra - cfra1) / dfra);
|
|
|
|
VecMulf(pa->state.vel, frs_sec / dfra);
|
|
|
|
pa->state.time = cfra;
|
|
}
|
|
|
|
static int ptcache_totpoint_particle(void *psys_v)
|
|
{
|
|
ParticleSystem *psys = psys_v;
|
|
return psys->totpart;
|
|
}
|
|
static int ptcache_totwrite_particle(void *psys_v)
|
|
{
|
|
ParticleSystem *psys = psys_v;
|
|
int totwrite = 0;
|
|
|
|
/* TODO for later */
|
|
//if((psys->part->flag & (PART_UNBORN|PART_DIED))==0) {
|
|
// ParticleData *pa= psys->particles;
|
|
// int p, step = psys->pointcache->step;
|
|
|
|
// for(p=0; p<psys->totpart; p++,pa++)
|
|
// totwrite += (pa->time - step > pa->state.time || pa->dietime + step > pa->state.time);
|
|
//}
|
|
//else
|
|
totwrite= psys->totpart;
|
|
|
|
return totwrite;
|
|
}
|
|
|
|
/* Cloth functions */
|
|
static int ptcache_write_cloth(int index, void *cloth_v, void **data)
|
|
{
|
|
ClothModifierData *clmd= cloth_v;
|
|
Cloth *cloth= clmd->clothObject;
|
|
ClothVertex *vert = cloth->verts + index;
|
|
|
|
ptcache_data_from(data, BPHYS_DATA_LOCATION, vert->x);
|
|
ptcache_data_from(data, BPHYS_DATA_VELOCITY, vert->v);
|
|
ptcache_data_from(data, BPHYS_DATA_XCONST, vert->xconst);
|
|
|
|
return 1;
|
|
}
|
|
static void ptcache_read_cloth(int index, void *cloth_v, void **data, float frs_sec, float cfra, float *old_data)
|
|
{
|
|
ClothModifierData *clmd= cloth_v;
|
|
Cloth *cloth= clmd->clothObject;
|
|
ClothVertex *vert = cloth->verts + index;
|
|
|
|
if(old_data) {
|
|
memcpy(vert->x, data, 3 * sizeof(float));
|
|
memcpy(vert->xconst, data + 3, 3 * sizeof(float));
|
|
memcpy(vert->v, data + 6, 3 * sizeof(float));
|
|
}
|
|
else {
|
|
ptcache_data_to(data, BPHYS_DATA_LOCATION, 0, vert->x);
|
|
ptcache_data_to(data, BPHYS_DATA_VELOCITY, 0, vert->v);
|
|
ptcache_data_to(data, BPHYS_DATA_XCONST, 0, vert->xconst);
|
|
}
|
|
}
|
|
static void ptcache_interpolate_cloth(int index, void *cloth_v, void **data, float frs_sec, float cfra, float cfra1, float cfra2, float *old_data)
|
|
{
|
|
ClothModifierData *clmd= cloth_v;
|
|
Cloth *cloth= clmd->clothObject;
|
|
ClothVertex *vert = cloth->verts + index;
|
|
ParticleKey keys[4];
|
|
float dfra;
|
|
|
|
if(cfra1 == cfra2)
|
|
return;
|
|
|
|
VECCOPY(keys[1].co, vert->x);
|
|
VECCOPY(keys[1].vel, vert->v);
|
|
|
|
if(old_data) {
|
|
memcpy(keys[2].co, old_data, 3 * sizeof(float));
|
|
memcpy(keys[2].vel, old_data + 6, 3 * sizeof(float));
|
|
}
|
|
else
|
|
BKE_ptcache_make_particle_key(keys+2, 0, data, cfra2);
|
|
|
|
dfra = cfra2 - cfra1;
|
|
|
|
VecMulf(keys[1].vel, dfra);
|
|
VecMulf(keys[2].vel, dfra);
|
|
|
|
psys_interpolate_particle(-1, keys, (cfra - cfra1) / dfra, keys, 1);
|
|
|
|
VecMulf(keys->vel, 1.0f / dfra);
|
|
|
|
VECCOPY(vert->x, keys->co);
|
|
VECCOPY(vert->v, keys->vel);
|
|
|
|
/* should vert->xconst be interpolated somehow too? - jahka */
|
|
}
|
|
|
|
static int ptcache_totpoint_cloth(void *cloth_v)
|
|
{
|
|
ClothModifierData *clmd= cloth_v;
|
|
return clmd->clothObject->numverts;
|
|
}
|
|
|
|
/* Creating ID's */
|
|
void BKE_ptcache_id_from_softbody(PTCacheID *pid, Object *ob, SoftBody *sb)
|
|
{
|
|
ParticleSystemModifierData *psmd;
|
|
|
|
memset(pid, 0, sizeof(PTCacheID));
|
|
|
|
pid->ob= ob;
|
|
pid->calldata= sb;
|
|
pid->type= PTCACHE_TYPE_SOFTBODY;
|
|
pid->cache= sb->pointcache;
|
|
pid->cache_ptr= &sb->pointcache;
|
|
pid->ptcaches= &sb->ptcaches;
|
|
pid->totpoint= pid->totwrite= ptcache_totpoint_softbody;
|
|
|
|
pid->write_elem= ptcache_write_softbody;
|
|
pid->write_stream = NULL;
|
|
pid->read_stream = NULL;
|
|
pid->read_elem= ptcache_read_softbody;
|
|
pid->interpolate_elem= ptcache_interpolate_softbody;
|
|
|
|
pid->write_header= ptcache_write_basic_header;
|
|
pid->read_header= ptcache_read_basic_header;
|
|
|
|
pid->data_types= (1<<BPHYS_DATA_LOCATION) | (1<<BPHYS_DATA_VELOCITY);
|
|
pid->info_types= 0;
|
|
|
|
if(sb->particles) {
|
|
psmd= psys_get_modifier(ob, sb->particles);
|
|
// pid->stack_index= modifiers_indexInObject(ob, (ModifierData*)psmd); XXX TODO - get other index DG
|
|
}
|
|
else
|
|
pid->stack_index = pid->cache->index;
|
|
}
|
|
|
|
void BKE_ptcache_id_from_particles(PTCacheID *pid, Object *ob, ParticleSystem *psys)
|
|
{
|
|
memset(pid, 0, sizeof(PTCacheID));
|
|
|
|
pid->ob= ob;
|
|
pid->calldata= psys;
|
|
pid->type= PTCACHE_TYPE_PARTICLES;
|
|
pid->stack_index= psys->pointcache->index;
|
|
pid->cache= psys->pointcache;
|
|
pid->cache_ptr= &psys->pointcache;
|
|
pid->ptcaches= &psys->ptcaches;
|
|
|
|
pid->flag |= PTCACHE_VEL_PER_SEC;
|
|
|
|
pid->write_elem= ptcache_write_particle;
|
|
pid->write_stream = NULL;
|
|
pid->read_stream = NULL;
|
|
pid->read_elem= ptcache_read_particle;
|
|
pid->interpolate_elem= ptcache_interpolate_particle;
|
|
|
|
pid->totpoint= ptcache_totpoint_particle;
|
|
pid->totwrite= ptcache_totwrite_particle;
|
|
|
|
pid->write_header= ptcache_write_basic_header;
|
|
pid->read_header= ptcache_read_basic_header;
|
|
|
|
pid->data_types= (1<<BPHYS_DATA_LOCATION) | (1<<BPHYS_DATA_VELOCITY);
|
|
|
|
/* TODO for later */
|
|
//if((psys->part->flag & (PART_UNBORN|PART_DIED))==0)
|
|
// pid->data_types|= (1<<BPHYS_DATA_INDEX);
|
|
|
|
if(psys->part->phystype == PART_PHYS_BOIDS)
|
|
pid->data_types|= (1<<BPHYS_DATA_AVELOCITY) | (1<<BPHYS_DATA_ROTATION) | (1<<BPHYS_DATA_BOIDS);
|
|
|
|
if(psys->part->rotmode || psys->part->avemode)
|
|
pid->data_types|= (1<<BPHYS_DATA_AVELOCITY) | (1<<BPHYS_DATA_ROTATION);
|
|
|
|
if(psys->part->flag & PART_ROT_DYN)
|
|
pid->data_types|= (1<<BPHYS_DATA_ROTATION);
|
|
|
|
pid->info_types= (1<<BPHYS_DATA_TIMES);
|
|
}
|
|
|
|
/* Smoke functions */
|
|
static int ptcache_totpoint_smoke(void *smoke_v)
|
|
{
|
|
SmokeModifierData *smd= (SmokeModifierData *)smoke_v;
|
|
SmokeDomainSettings *sds = smd->domain;
|
|
|
|
if(sds->fluid) {
|
|
return sds->res[0]*sds->res[1]*sds->res[2];
|
|
}
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
// forward decleration
|
|
static int ptcache_file_write(PTCacheFile *pf, void *f, size_t tot, int size);
|
|
|
|
static int ptcache_compress_write(PTCacheFile *pf, unsigned char *in, unsigned int in_len, unsigned char *out, int mode)
|
|
{
|
|
int r = 0;
|
|
unsigned char compressed;
|
|
LZO_HEAP_ALLOC(wrkmem, LZO1X_MEM_COMPRESS);
|
|
unsigned int out_len = LZO_OUT_LEN(in_len);
|
|
unsigned char *props = MEM_callocN(16*sizeof(char), "tmp");
|
|
size_t sizeOfIt = 5;
|
|
|
|
if(mode == 1) {
|
|
r = lzo1x_1_compress(in, (lzo_uint)in_len, out, (lzo_uint *)&out_len, wrkmem);
|
|
if (!(r == LZO_E_OK) || (out_len >= in_len))
|
|
compressed = 0;
|
|
else
|
|
compressed = 1;
|
|
}
|
|
else if(mode == 2) {
|
|
|
|
r = LzmaCompress(out, (size_t *)&out_len, in, in_len,//assume sizeof(char)==1....
|
|
props, &sizeOfIt, 5, 1 << 24, 3, 0, 2, 32, 2);
|
|
|
|
if(!(r == SZ_OK) || (out_len >= in_len))
|
|
compressed = 0;
|
|
else
|
|
compressed = 2;
|
|
}
|
|
|
|
ptcache_file_write(pf, &compressed, 1, sizeof(unsigned char));
|
|
if(compressed) {
|
|
ptcache_file_write(pf, &out_len, 1, sizeof(unsigned int));
|
|
ptcache_file_write(pf, out, out_len, sizeof(unsigned char));
|
|
}
|
|
else
|
|
ptcache_file_write(pf, in, in_len, sizeof(unsigned char));
|
|
|
|
if(compressed == 2)
|
|
{
|
|
ptcache_file_write(pf, &sizeOfIt, 1, sizeof(unsigned int));
|
|
ptcache_file_write(pf, props, sizeOfIt, sizeof(unsigned char));
|
|
}
|
|
|
|
MEM_freeN(props);
|
|
|
|
return r;
|
|
}
|
|
|
|
static int ptcache_write_smoke(PTCacheFile *pf, void *smoke_v)
|
|
{
|
|
SmokeModifierData *smd= (SmokeModifierData *)smoke_v;
|
|
SmokeDomainSettings *sds = smd->domain;
|
|
|
|
if(sds->fluid) {
|
|
size_t res = sds->res[0]*sds->res[1]*sds->res[2];
|
|
float dt, dx, *dens, *densold, *heat, *heatold, *vx, *vy, *vz, *vxold, *vyold, *vzold;
|
|
unsigned char *obstacles;
|
|
unsigned int in_len = sizeof(float)*(unsigned int)res;
|
|
unsigned char *out = (unsigned char *)MEM_callocN(LZO_OUT_LEN(in_len)*4, "pointcache_lzo_buffer");
|
|
int mode = res >= 1000000 ? 2 : 1;
|
|
|
|
smoke_export(sds->fluid, &dt, &dx, &dens, &densold, &heat, &heatold, &vx, &vy, &vz, &vxold, &vyold, &vzold, &obstacles);
|
|
|
|
ptcache_compress_write(pf, (unsigned char *)sds->view3d, in_len*4, out, mode);
|
|
ptcache_compress_write(pf, (unsigned char *)dens, in_len, out, mode);
|
|
ptcache_compress_write(pf, (unsigned char *)densold, in_len, out, mode);
|
|
ptcache_compress_write(pf, (unsigned char *)heat, in_len, out, mode);
|
|
ptcache_compress_write(pf, (unsigned char *)heatold, in_len, out, mode);
|
|
ptcache_compress_write(pf, (unsigned char *)vx, in_len, out, mode);
|
|
ptcache_compress_write(pf, (unsigned char *)vy, in_len, out, mode);
|
|
ptcache_compress_write(pf, (unsigned char *)vz, in_len, out, mode);
|
|
ptcache_compress_write(pf, (unsigned char *)vxold, in_len, out, mode);
|
|
ptcache_compress_write(pf, (unsigned char *)vyold, in_len, out, mode);
|
|
ptcache_compress_write(pf, (unsigned char *)vzold, in_len, out, mode);
|
|
ptcache_compress_write(pf, (unsigned char *)obstacles, (unsigned int)res, out, mode);
|
|
ptcache_file_write(pf, &dt, 1, sizeof(float));
|
|
ptcache_file_write(pf, &dx, 1, sizeof(float));
|
|
|
|
MEM_freeN(out);
|
|
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
static int ptcache_write_smoke_turbulence(PTCacheFile *pf, void *smoke_v)
|
|
{
|
|
SmokeModifierData *smd= (SmokeModifierData *)smoke_v;
|
|
SmokeDomainSettings *sds = smd->domain;
|
|
|
|
if(sds->wt) {
|
|
unsigned int res_big[3];
|
|
size_t res = sds->res[0]*sds->res[1]*sds->res[2];
|
|
float *dens, *densold, *tcu, *tcv, *tcw;
|
|
unsigned int in_len = sizeof(float)*(unsigned int)res;
|
|
unsigned int in_len_big = sizeof(float) * (unsigned int)res_big;
|
|
unsigned char *out;
|
|
int mode;
|
|
|
|
smoke_turbulence_get_res(sds->wt, res_big);
|
|
mode = res_big[0]*res_big[1]*res_big[2] >= 1000000 ? 2 : 1;
|
|
|
|
smoke_turbulence_export(sds->wt, &dens, &densold, &tcu, &tcv, &tcw);
|
|
|
|
out = (unsigned char *)MEM_callocN(LZO_OUT_LEN(in_len_big), "pointcache_lzo_buffer");
|
|
|
|
ptcache_compress_write(pf, (unsigned char *)dens, in_len_big, out, mode);
|
|
ptcache_compress_write(pf, (unsigned char *)densold, in_len_big, out, mode);
|
|
|
|
MEM_freeN(out);
|
|
out = (unsigned char *)MEM_callocN(LZO_OUT_LEN(in_len), "pointcache_lzo_buffer");
|
|
ptcache_compress_write(pf, (unsigned char *)tcu, in_len, out, mode);
|
|
ptcache_compress_write(pf, (unsigned char *)tcv, in_len, out, mode);
|
|
ptcache_compress_write(pf, (unsigned char *)tcw, in_len, out, mode);
|
|
MEM_freeN(out);
|
|
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
*/
|
|
|
|
// forward decleration
|
|
static int ptcache_file_read(PTCacheFile *pf, void *f, size_t tot, int size);
|
|
|
|
static int ptcache_compress_read(PTCacheFile *pf, unsigned char *result, unsigned int len)
|
|
{
|
|
int r = 0;
|
|
unsigned char compressed = 0;
|
|
unsigned int in_len;
|
|
unsigned int out_len = len;
|
|
unsigned char *in;
|
|
unsigned char *props = MEM_callocN(16*sizeof(char), "tmp");
|
|
size_t sizeOfIt = 5;
|
|
|
|
ptcache_file_read(pf, &compressed, 1, sizeof(unsigned char));
|
|
if(compressed) {
|
|
ptcache_file_read(pf, &in_len, 1, sizeof(unsigned int));
|
|
in = (unsigned char *)MEM_callocN(sizeof(unsigned char)*in_len, "pointcache_compressed_buffer");
|
|
ptcache_file_read(pf, in, in_len, sizeof(unsigned char));
|
|
|
|
if(compressed == 1)
|
|
r = lzo1x_decompress(in, (lzo_uint)in_len, result, (lzo_uint *)&out_len, NULL);
|
|
else if(compressed == 2)
|
|
{
|
|
size_t leni = in_len, leno = out_len;
|
|
ptcache_file_read(pf, &sizeOfIt, 1, sizeof(unsigned int));
|
|
ptcache_file_read(pf, props, sizeOfIt, sizeof(unsigned char));
|
|
r = LzmaUncompress(result, &leno, in, &leni, props, sizeOfIt);
|
|
}
|
|
|
|
MEM_freeN(in);
|
|
}
|
|
else {
|
|
ptcache_file_read(pf, result, len, sizeof(unsigned char));
|
|
}
|
|
|
|
MEM_freeN(props);
|
|
|
|
return r;
|
|
}
|
|
|
|
static void ptcache_read_smoke(PTCacheFile *pf, void *smoke_v)
|
|
{
|
|
SmokeModifierData *smd= (SmokeModifierData *)smoke_v;
|
|
SmokeDomainSettings *sds = smd->domain;
|
|
|
|
if(sds->fluid) {
|
|
size_t res = sds->res[0]*sds->res[1]*sds->res[2];
|
|
float dt, dx, *dens, *densold, *heat, *heatold, *vx, *vy, *vz, *vxold, *vyold, *vzold;
|
|
unsigned char *obstacles;
|
|
unsigned int out_len = (unsigned int)res * sizeof(float);
|
|
|
|
smoke_export(sds->fluid, &dt, &dx, &dens, &densold, &heat, &heatold, &vx, &vy, &vz, &vxold, &vyold, &vzold, &obstacles);
|
|
|
|
ptcache_compress_read(pf, (unsigned char *)sds->view3d, out_len*4);
|
|
ptcache_compress_read(pf, (unsigned char*)dens, out_len);
|
|
ptcache_compress_read(pf, (unsigned char*)densold, out_len);
|
|
ptcache_compress_read(pf, (unsigned char*)heat, out_len);
|
|
ptcache_compress_read(pf, (unsigned char*)heatold, out_len);
|
|
ptcache_compress_read(pf, (unsigned char*)vx, out_len);
|
|
ptcache_compress_read(pf, (unsigned char*)vy, out_len);
|
|
ptcache_compress_read(pf, (unsigned char*)vz, out_len);
|
|
ptcache_compress_read(pf, (unsigned char*)vxold, out_len);
|
|
ptcache_compress_read(pf, (unsigned char*)vyold, out_len);
|
|
ptcache_compress_read(pf, (unsigned char*)vzold, out_len);
|
|
ptcache_compress_read(pf, (unsigned char*)obstacles, (unsigned int)res);
|
|
ptcache_file_read(pf, &dt, 1, sizeof(float));
|
|
ptcache_file_read(pf, &dx, 1, sizeof(float));
|
|
}
|
|
}
|
|
|
|
/*
|
|
static void ptcache_read_smoke_turbulence(PTCacheFile *pf, void *smoke_v)
|
|
{
|
|
SmokeModifierData *smd= (SmokeModifierData *)smoke_v;
|
|
SmokeDomainSettings *sds = smd->domain;
|
|
|
|
if(sds->fluid) {
|
|
unsigned int res[3];
|
|
float *dens, *densold, *tcu, *tcv, *tcw;
|
|
unsigned int out_len = sizeof(float)*(unsigned int)res;
|
|
|
|
smoke_turbulence_get_res(sds->wt, res);
|
|
|
|
smoke_turbulence_export(sds->wt, &dens, &densold, &tcu, &tcv, &tcw);
|
|
|
|
ptcache_compress_read(pf, (unsigned char*)dens, out_len);
|
|
|
|
}
|
|
}
|
|
*/
|
|
|
|
void BKE_ptcache_id_from_smoke(PTCacheID *pid, struct Object *ob, struct SmokeModifierData *smd)
|
|
{
|
|
SmokeDomainSettings *sds = smd->domain;
|
|
|
|
memset(pid, 0, sizeof(PTCacheID));
|
|
|
|
pid->ob= ob;
|
|
pid->calldata= smd;
|
|
|
|
pid->type= PTCACHE_TYPE_SMOKE_DOMAIN;
|
|
pid->stack_index= sds->point_cache[0]->index;
|
|
|
|
pid->cache= sds->point_cache[0];
|
|
pid->cache_ptr= &(sds->point_cache[0]);
|
|
pid->ptcaches= &(sds->ptcaches[0]);
|
|
|
|
pid->totpoint= pid->totwrite= ptcache_totpoint_smoke;
|
|
|
|
pid->write_elem= NULL;
|
|
pid->read_elem= NULL;
|
|
|
|
pid->read_stream = ptcache_read_smoke;
|
|
pid->write_stream = ptcache_write_smoke;
|
|
|
|
pid->interpolate_elem= NULL;
|
|
|
|
pid->write_header= ptcache_write_basic_header;
|
|
pid->read_header= ptcache_read_basic_header;
|
|
|
|
pid->data_types= (1<<BPHYS_DATA_LOCATION); // bogus values tot make pointcache happy
|
|
pid->info_types= 0;
|
|
}
|
|
|
|
void BKE_ptcache_id_from_smoke_turbulence(PTCacheID *pid, struct Object *ob, struct SmokeModifierData *smd)
|
|
{
|
|
SmokeDomainSettings *sds = smd->domain;
|
|
|
|
memset(pid, 0, sizeof(PTCacheID));
|
|
|
|
pid->ob= ob;
|
|
pid->calldata= smd;
|
|
|
|
pid->type= PTCACHE_TYPE_SMOKE_HIGHRES;
|
|
pid->stack_index= sds->point_cache[1]->index;
|
|
|
|
pid->cache= sds->point_cache[1];
|
|
pid->cache_ptr= &sds->point_cache[1];
|
|
pid->ptcaches= &sds->ptcaches[1];
|
|
|
|
pid->totpoint= pid->totwrite= ptcache_totpoint_smoke;
|
|
|
|
pid->write_elem= NULL;
|
|
pid->read_elem= NULL;
|
|
|
|
pid->read_stream = ptcache_read_smoke;
|
|
pid->write_stream = ptcache_write_smoke;
|
|
|
|
pid->interpolate_elem= NULL;
|
|
|
|
pid->write_header= ptcache_write_basic_header;
|
|
pid->read_header= ptcache_read_basic_header;
|
|
|
|
pid->data_types= (1<<BPHYS_DATA_LOCATION); // bogus values tot make pointcache happy
|
|
pid->info_types= 0;
|
|
}
|
|
|
|
void BKE_ptcache_id_from_cloth(PTCacheID *pid, Object *ob, ClothModifierData *clmd)
|
|
{
|
|
memset(pid, 0, sizeof(PTCacheID));
|
|
|
|
pid->ob= ob;
|
|
pid->calldata= clmd;
|
|
pid->type= PTCACHE_TYPE_CLOTH;
|
|
pid->stack_index= clmd->point_cache->index;
|
|
pid->cache= clmd->point_cache;
|
|
pid->cache_ptr= &clmd->point_cache;
|
|
pid->ptcaches= &clmd->ptcaches;
|
|
pid->totpoint= pid->totwrite= ptcache_totpoint_cloth;
|
|
|
|
pid->write_elem= ptcache_write_cloth;
|
|
pid->write_stream = NULL;
|
|
pid->read_stream = NULL;
|
|
pid->read_elem= ptcache_read_cloth;
|
|
pid->interpolate_elem= ptcache_interpolate_cloth;
|
|
|
|
pid->write_header= ptcache_write_basic_header;
|
|
pid->read_header= ptcache_read_basic_header;
|
|
|
|
pid->data_types= (1<<BPHYS_DATA_LOCATION) | (1<<BPHYS_DATA_VELOCITY) | (1<<BPHYS_DATA_XCONST);
|
|
pid->info_types= 0;
|
|
}
|
|
|
|
void BKE_ptcache_ids_from_object(ListBase *lb, Object *ob)
|
|
{
|
|
PTCacheID *pid;
|
|
ParticleSystem *psys;
|
|
ModifierData *md;
|
|
|
|
lb->first= lb->last= NULL;
|
|
|
|
if(ob->soft) {
|
|
pid= MEM_callocN(sizeof(PTCacheID), "PTCacheID");
|
|
BKE_ptcache_id_from_softbody(pid, ob, ob->soft);
|
|
BLI_addtail(lb, pid);
|
|
}
|
|
|
|
for(psys=ob->particlesystem.first; psys; psys=psys->next) {
|
|
if(psys->part) {
|
|
pid= MEM_callocN(sizeof(PTCacheID), "PTCacheID");
|
|
BKE_ptcache_id_from_particles(pid, ob, psys);
|
|
BLI_addtail(lb, pid);
|
|
|
|
if(psys->soft) {
|
|
pid= MEM_callocN(sizeof(PTCacheID), "PTCacheID");
|
|
BKE_ptcache_id_from_softbody(pid, ob, psys->soft);
|
|
BLI_addtail(lb, pid);
|
|
}
|
|
}
|
|
}
|
|
|
|
for(md=ob->modifiers.first; md; md=md->next) {
|
|
if(md->type == eModifierType_Cloth) {
|
|
pid= MEM_callocN(sizeof(PTCacheID), "PTCacheID");
|
|
BKE_ptcache_id_from_cloth(pid, ob, (ClothModifierData*)md);
|
|
BLI_addtail(lb, pid);
|
|
}
|
|
if(md->type == eModifierType_Smoke) {
|
|
SmokeModifierData *smd = (SmokeModifierData *)md;
|
|
if(smd->type & MOD_SMOKE_TYPE_DOMAIN)
|
|
{
|
|
pid= MEM_callocN(sizeof(PTCacheID), "PTCacheID");
|
|
BKE_ptcache_id_from_smoke(pid, ob, (SmokeModifierData*)md);
|
|
BLI_addtail(lb, pid);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/* File handling */
|
|
|
|
/* Takes an Object ID and returns a unique name
|
|
- id: object id
|
|
- cfra: frame for the cache, can be negative
|
|
- stack_index: index in the modifier stack. we can have cache for more then one stack_index
|
|
*/
|
|
|
|
#define MAX_PTCACHE_PATH FILE_MAX
|
|
#define MAX_PTCACHE_FILE ((FILE_MAXDIR+FILE_MAXFILE)*2)
|
|
|
|
static int ptcache_path(PTCacheID *pid, char *filename)
|
|
{
|
|
Library *lib;
|
|
size_t i;
|
|
|
|
lib= (pid)? pid->ob->id.lib: NULL;
|
|
|
|
if(pid->cache->flag & PTCACHE_EXTERNAL) {
|
|
strcpy(filename, pid->cache->path);
|
|
return BLI_add_slash(filename); /* new strlen() */
|
|
}
|
|
else if (G.relbase_valid || lib) {
|
|
char file[MAX_PTCACHE_PATH]; /* we dont want the dir, only the file */
|
|
char *blendfilename;
|
|
|
|
blendfilename= (lib)? lib->filename: G.sce;
|
|
|
|
BLI_split_dirfile_basic(blendfilename, NULL, file);
|
|
i = strlen(file);
|
|
|
|
/* remove .blend */
|
|
if (i > 6)
|
|
file[i-6] = '\0';
|
|
|
|
snprintf(filename, MAX_PTCACHE_PATH, "//"PTCACHE_PATH"%s", file); /* add blend file name to pointcache dir */
|
|
BLI_convertstringcode(filename, blendfilename);
|
|
return BLI_add_slash(filename); /* new strlen() */
|
|
}
|
|
|
|
/* use the temp path. this is weak but better then not using point cache at all */
|
|
/* btempdir is assumed to exist and ALWAYS has a trailing slash */
|
|
snprintf(filename, MAX_PTCACHE_PATH, "%s"PTCACHE_PATH"%d", btempdir, abs(getpid()));
|
|
|
|
return BLI_add_slash(filename); /* new strlen() */
|
|
}
|
|
|
|
static int BKE_ptcache_id_filename(PTCacheID *pid, char *filename, int cfra, short do_path, short do_ext)
|
|
{
|
|
int len=0;
|
|
char *idname;
|
|
char *newname;
|
|
filename[0] = '\0';
|
|
newname = filename;
|
|
|
|
if (!G.relbase_valid && (pid->cache->flag & PTCACHE_EXTERNAL)==0) return 0; /* save blend file before using disk pointcache */
|
|
|
|
/* start with temp dir */
|
|
if (do_path) {
|
|
len = ptcache_path(pid, filename);
|
|
newname += len;
|
|
}
|
|
if(strcmp(pid->cache->name, "")==0 && (pid->cache->flag & PTCACHE_EXTERNAL)==0) {
|
|
idname = (pid->ob->id.name+2);
|
|
/* convert chars to hex so they are always a valid filename */
|
|
while('\0' != *idname) {
|
|
snprintf(newname, MAX_PTCACHE_FILE, "%02X", (char)(*idname++));
|
|
newname+=2;
|
|
len += 2;
|
|
}
|
|
}
|
|
else {
|
|
int temp = (int)strlen(pid->cache->name);
|
|
strcpy(newname, pid->cache->name);
|
|
newname+=temp;
|
|
len += temp;
|
|
}
|
|
|
|
if (do_ext) {
|
|
|
|
if(pid->cache->index < 0)
|
|
pid->cache->index = pid->stack_index = object_insert_ptcache(pid->ob);
|
|
|
|
if(pid->cache->flag & PTCACHE_EXTERNAL) {
|
|
if(pid->cache->index >= 0)
|
|
snprintf(newname, MAX_PTCACHE_FILE, "_%06d_%02d"PTCACHE_EXT, cfra, pid->stack_index); /* always 6 chars */
|
|
else
|
|
snprintf(newname, MAX_PTCACHE_FILE, "_%06d"PTCACHE_EXT, cfra); /* always 6 chars */
|
|
}
|
|
else {
|
|
snprintf(newname, MAX_PTCACHE_FILE, "_%06d_%02d"PTCACHE_EXT, cfra, pid->stack_index); /* always 6 chars */
|
|
}
|
|
len += 16;
|
|
}
|
|
|
|
return len; /* make sure the above string is always 16 chars */
|
|
}
|
|
|
|
/* youll need to close yourself after! */
|
|
static PTCacheFile *ptcache_file_open(PTCacheID *pid, int mode, int cfra)
|
|
{
|
|
PTCacheFile *pf;
|
|
FILE *fp = NULL;
|
|
char filename[(FILE_MAXDIR+FILE_MAXFILE)*2];
|
|
|
|
/* don't allow writing for linked objects */
|
|
if(pid->ob->id.lib && mode == PTCACHE_FILE_WRITE)
|
|
return NULL;
|
|
|
|
if (!G.relbase_valid && (pid->cache->flag & PTCACHE_EXTERNAL)==0) return NULL; /* save blend file before using disk pointcache */
|
|
|
|
BKE_ptcache_id_filename(pid, filename, cfra, 1, 1);
|
|
|
|
if (mode==PTCACHE_FILE_READ) {
|
|
if (!BLI_exists(filename)) {
|
|
return NULL;
|
|
}
|
|
fp = fopen(filename, "rb");
|
|
} else if (mode==PTCACHE_FILE_WRITE) {
|
|
BLI_make_existing_file(filename); /* will create the dir if needs be, same as //textures is created */
|
|
fp = fopen(filename, "wb");
|
|
}
|
|
|
|
if (!fp)
|
|
return NULL;
|
|
|
|
pf= MEM_mallocN(sizeof(PTCacheFile), "PTCacheFile");
|
|
pf->fp= fp;
|
|
|
|
return pf;
|
|
}
|
|
|
|
static void ptcache_file_close(PTCacheFile *pf)
|
|
{
|
|
fclose(pf->fp);
|
|
MEM_freeN(pf);
|
|
}
|
|
|
|
static int ptcache_file_read(PTCacheFile *pf, void *f, size_t tot, int size)
|
|
{
|
|
return (fread(f, size, tot, pf->fp) == tot);
|
|
}
|
|
static int ptcache_file_write(PTCacheFile *pf, void *f, size_t tot, int size)
|
|
{
|
|
return (fwrite(f, size, tot, pf->fp) == tot);
|
|
}
|
|
static int ptcache_file_read_data(PTCacheFile *pf)
|
|
{
|
|
int i;
|
|
|
|
for(i=0; i<BPHYS_TOT_DATA; i++) {
|
|
if(pf->data_types & (1<<i) && !ptcache_file_read(pf, pf->cur[i], 1, BKE_ptcache_data_size(i)))
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
static int ptcache_file_write_data(PTCacheFile *pf)
|
|
{
|
|
int i;
|
|
|
|
for(i=0; i<BPHYS_TOT_DATA; i++) {
|
|
if(pf->data_types & (1<<i) && !ptcache_file_write(pf, pf->cur[i], 1, BKE_ptcache_data_size(i)))
|
|
return 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
static int ptcache_file_read_header_begin(PTCacheFile *pf)
|
|
{
|
|
int error=0;
|
|
char bphysics[8];
|
|
|
|
pf->data_types = 0;
|
|
|
|
if(fread(bphysics, sizeof(char), 8, pf->fp) != 8)
|
|
error = 1;
|
|
|
|
if(!error && strncmp(bphysics, "BPHYSICS", 8))
|
|
error = 1;
|
|
|
|
if(!error && !fread(&pf->type, sizeof(int), 1, pf->fp))
|
|
error = 1;
|
|
|
|
/* if there was an error set file as it was */
|
|
if(error)
|
|
fseek(pf->fp, 0, SEEK_SET);
|
|
|
|
return !error;
|
|
}
|
|
|
|
|
|
static int ptcache_file_write_header_begin(PTCacheFile *pf)
|
|
{
|
|
char *bphysics = "BPHYSICS";
|
|
|
|
if(fwrite(bphysics, sizeof(char), 8, pf->fp) != 8)
|
|
return 0;
|
|
|
|
if(!fwrite(&pf->type, sizeof(int), 1, pf->fp))
|
|
return 0;
|
|
|
|
return 1;
|
|
}
|
|
|
|
|
|
/* Data pointer handling */
|
|
int BKE_ptcache_data_size(int data_type)
|
|
{
|
|
switch(data_type) {
|
|
case BPHYS_DATA_INDEX:
|
|
return sizeof(int);
|
|
case BPHYS_DATA_LOCATION:
|
|
case BPHYS_DATA_VELOCITY:
|
|
case BPHYS_DATA_AVELOCITY: /* also BPHYS_DATA_XCONST */
|
|
case BPHYS_DATA_TIMES:
|
|
return 3 * sizeof(float);
|
|
case BPHYS_DATA_ROTATION:
|
|
return 4 * sizeof(float);
|
|
case BPHYS_DATA_SIZE:
|
|
return sizeof(float);
|
|
case BPHYS_DATA_BOIDS:
|
|
return sizeof(BoidData);
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
static void ptcache_data_to(void **data, int type, int index, void *to)
|
|
{
|
|
if(data[type]) {
|
|
if(index)
|
|
memcpy(to, (char*)data[type] + index * BKE_ptcache_data_size(type), BKE_ptcache_data_size(type));
|
|
else
|
|
memcpy(to, data[type], BKE_ptcache_data_size(type));
|
|
}
|
|
}
|
|
|
|
static void ptcache_data_from(void **data, int type, void *from)
|
|
{
|
|
if(data[type])
|
|
memcpy(data[type], from, BKE_ptcache_data_size(type));
|
|
}
|
|
|
|
static void ptcache_file_init_pointers(PTCacheFile *pf)
|
|
{
|
|
int data_types = pf->data_types;
|
|
|
|
pf->cur[BPHYS_DATA_INDEX] = data_types & (1<<BPHYS_DATA_INDEX) ? &pf->data.index : NULL;
|
|
pf->cur[BPHYS_DATA_LOCATION] = data_types & (1<<BPHYS_DATA_LOCATION) ? &pf->data.loc : NULL;
|
|
pf->cur[BPHYS_DATA_VELOCITY] = data_types & (1<<BPHYS_DATA_VELOCITY) ? &pf->data.vel : NULL;
|
|
pf->cur[BPHYS_DATA_ROTATION] = data_types & (1<<BPHYS_DATA_ROTATION) ? &pf->data.rot : NULL;
|
|
pf->cur[BPHYS_DATA_AVELOCITY] = data_types & (1<<BPHYS_DATA_AVELOCITY) ? &pf->data.ave : NULL;
|
|
pf->cur[BPHYS_DATA_SIZE] = data_types & (1<<BPHYS_DATA_SIZE) ? &pf->data.size : NULL;
|
|
pf->cur[BPHYS_DATA_TIMES] = data_types & (1<<BPHYS_DATA_TIMES) ? &pf->data.times : NULL;
|
|
pf->cur[BPHYS_DATA_BOIDS] = data_types & (1<<BPHYS_DATA_BOIDS) ? &pf->data.boids : NULL;
|
|
}
|
|
|
|
void BKE_ptcache_mem_init_pointers(PTCacheMem *pm)
|
|
{
|
|
int data_types = pm->data_types;
|
|
int i;
|
|
|
|
for(i=0; i<BPHYS_TOT_DATA; i++)
|
|
pm->cur[i] = data_types & (1<<i) ? pm->data[i] : NULL;
|
|
}
|
|
|
|
void BKE_ptcache_mem_incr_pointers(PTCacheMem *pm)
|
|
{
|
|
int i;
|
|
|
|
for(i=0; i<BPHYS_TOT_DATA; i++) {
|
|
if(pm->cur[i])
|
|
pm->cur[i] = (char*)pm->cur[i] + BKE_ptcache_data_size(i);
|
|
}
|
|
}
|
|
static void ptcache_alloc_data(PTCacheMem *pm)
|
|
{
|
|
int data_types = pm->data_types;
|
|
int totpoint = pm->totpoint;
|
|
int i;
|
|
|
|
for(i=0; i<BPHYS_TOT_DATA; i++) {
|
|
if(data_types & (1<<i))
|
|
pm->data[i] = MEM_callocN(totpoint * BKE_ptcache_data_size(i), "PTCache Data");
|
|
}
|
|
}
|
|
static void ptcache_free_data(void *data[])
|
|
{
|
|
int i;
|
|
|
|
for(i=0; i<BPHYS_TOT_DATA; i++) {
|
|
if(data[i])
|
|
MEM_freeN(data[i]);
|
|
}
|
|
}
|
|
static void ptcache_copy_data(void *from[], void *to[])
|
|
{
|
|
int i;
|
|
for(i=0; i<BPHYS_TOT_DATA; i++) {
|
|
if(from[i])
|
|
memcpy(to[i], from[i], BKE_ptcache_data_size(i));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
static int ptcache_pid_old_elemsize(PTCacheID *pid)
|
|
{
|
|
if(pid->type==PTCACHE_TYPE_SOFTBODY)
|
|
return 6 * sizeof(float);
|
|
else if(pid->type==PTCACHE_TYPE_PARTICLES)
|
|
return sizeof(ParticleKey);
|
|
else if(pid->type==PTCACHE_TYPE_CLOTH)
|
|
return 9 * sizeof(float);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* reads cache from disk or memory */
|
|
/* possible to get old or interpolated result */
|
|
int BKE_ptcache_read_cache(PTCacheID *pid, float cfra, float frs_sec)
|
|
{
|
|
PTCacheFile *pf=NULL, *pf2=NULL;
|
|
PTCacheMem *pm=NULL, *pm2=NULL;
|
|
float old_data1[14], old_data2[14];
|
|
int cfrai = (int)cfra;
|
|
int old_elemsize = ptcache_pid_old_elemsize(pid);
|
|
int i;
|
|
|
|
int cfra1 = 0, cfra2 = 0;
|
|
int totpoint = 0, totpoint2 = 0;
|
|
int *index = &i, *index2 = &i;
|
|
int use_old = 0, old_frame = 0;
|
|
|
|
int ret = 0, error = 0;
|
|
|
|
/* nothing to read to */
|
|
if(pid->totpoint(pid->calldata) == 0)
|
|
return 0;
|
|
|
|
if(pid->cache->flag & PTCACHE_READ_INFO) {
|
|
pid->cache->flag &= ~PTCACHE_READ_INFO;
|
|
BKE_ptcache_read_cache(pid, 0, frs_sec);
|
|
}
|
|
|
|
|
|
/* first check if we have the actual frame cached */
|
|
if(cfra == (float)cfrai) {
|
|
if(pid->cache->flag & PTCACHE_DISK_CACHE) {
|
|
pf= ptcache_file_open(pid, PTCACHE_FILE_READ, cfrai);
|
|
}
|
|
else {
|
|
pm = pid->cache->mem_cache.first;
|
|
|
|
for(; pm; pm=pm->next) {
|
|
if(pm->frame == cfrai)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* no exact cache frame found so try to find cached frames around cfra */
|
|
if(!pm && !pf) {
|
|
if(pid->cache->flag & PTCACHE_DISK_CACHE) {
|
|
pf=NULL;
|
|
while(cfrai > pid->cache->startframe && !pf) {
|
|
cfrai--;
|
|
pf= ptcache_file_open(pid, PTCACHE_FILE_READ, cfrai);
|
|
cfra1 = cfrai;
|
|
}
|
|
|
|
old_frame = cfrai;
|
|
|
|
cfrai = (int)cfra;
|
|
while(cfrai < pid->cache->endframe && !pf2) {
|
|
cfrai++;
|
|
pf2= ptcache_file_open(pid, PTCACHE_FILE_READ, cfrai);
|
|
cfra2 = cfrai;
|
|
}
|
|
|
|
if(pf && !pf2) {
|
|
pf2 = pf;
|
|
pf = NULL;
|
|
}
|
|
}
|
|
else if(pid->cache->mem_cache.first){
|
|
pm = pid->cache->mem_cache.first;
|
|
|
|
while(pm->next && pm->next->frame < cfra)
|
|
pm= pm->next;
|
|
|
|
if(pm) {
|
|
old_frame = pm->frame;
|
|
cfra1 = pm->frame;
|
|
}
|
|
|
|
pm2 = pid->cache->mem_cache.last;
|
|
|
|
if(pm2 && pm2->frame < cfra)
|
|
pm2 = NULL;
|
|
else {
|
|
while(pm2->prev && pm2->prev->frame > cfra)
|
|
pm2= pm2->prev;
|
|
|
|
if(pm2)
|
|
cfra2 = pm2->frame;
|
|
}
|
|
|
|
if(pm && !pm2) {
|
|
pm2 = pm;
|
|
pm = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!pm && !pm2 && !pf && !pf2)
|
|
return 0;
|
|
|
|
if(pm) {
|
|
BKE_ptcache_mem_init_pointers(pm);
|
|
totpoint = pm->totpoint;
|
|
index = pm->data_types & (1<<BPHYS_DATA_INDEX) ? pm->cur[BPHYS_DATA_INDEX] : &i;
|
|
}
|
|
if(pm2) {
|
|
BKE_ptcache_mem_init_pointers(pm2);
|
|
totpoint2 = pm2->totpoint;
|
|
index2 = pm2->data_types & (1<<BPHYS_DATA_INDEX) ? pm2->cur[BPHYS_DATA_INDEX] : &i;
|
|
}
|
|
if(pf) {
|
|
if(ptcache_file_read_header_begin(pf)) {
|
|
if(pf->type != pid->type) {
|
|
/* todo report error */
|
|
ptcache_file_close(pf);
|
|
pf = NULL;
|
|
}
|
|
else if(pid->read_header(pf)) {
|
|
ptcache_file_init_pointers(pf);
|
|
totpoint = pf->totpoint;
|
|
index = pf->data_types & BPHYS_DATA_INDEX ? &pf->data.index : &i;
|
|
}
|
|
}
|
|
else {
|
|
/* fall back to old cache file format */
|
|
use_old = 1;
|
|
totpoint = pid->totpoint(pid->calldata);
|
|
}
|
|
}
|
|
if(pf2) {
|
|
if(ptcache_file_read_header_begin(pf2)) {
|
|
if(pf2->type != pid->type) {
|
|
/* todo report error */
|
|
ptcache_file_close(pf2);
|
|
pf2 = NULL;
|
|
}
|
|
else if(pid->read_header(pf2)) {
|
|
ptcache_file_init_pointers(pf2);
|
|
totpoint2 = pf2->totpoint;
|
|
index2 = pf->data_types & BPHYS_DATA_INDEX ? &pf2->data.index : &i;
|
|
}
|
|
}
|
|
else {
|
|
/* fall back to old cache file format */
|
|
use_old = 1;
|
|
totpoint2 = pid->totpoint(pid->calldata);
|
|
}
|
|
}
|
|
|
|
/* don't read old cache if allready simulated past cached frame */
|
|
if(!pm && !pf && cfra1 && cfra1 <= pid->cache->simframe)
|
|
error = 1;
|
|
if(cfra1 && cfra1==cfra2)
|
|
error = 1;
|
|
|
|
if(!error)
|
|
{
|
|
if(pf && pid->read_stream) {
|
|
if(totpoint != pid->totpoint(pid->calldata))
|
|
error = 1;
|
|
else
|
|
{
|
|
// we have stream writing here
|
|
pid->read_stream(pf, pid->calldata);
|
|
}
|
|
}
|
|
}
|
|
|
|
totpoint = MIN2(totpoint, pid->totpoint(pid->calldata));
|
|
|
|
if(!error)
|
|
{
|
|
for(i=0; i<totpoint; i++) {
|
|
/* read old cache file format */
|
|
if(use_old) {
|
|
if(pid->read_elem && ptcache_file_read(pf, (void*)old_data1, 1, old_elemsize))
|
|
pid->read_elem(i, pid->calldata, NULL, frs_sec, cfra, old_data1);
|
|
else if(pid->read_elem)
|
|
{ error = 1; break; }
|
|
}
|
|
else {
|
|
if(pid->read_elem && (pm || ptcache_file_read_data(pf)))
|
|
pid->read_elem(*index, pid->calldata, pm ? pm->cur : pf->cur, frs_sec, cfra1 ? (float)cfra1 : (float)cfrai, NULL);
|
|
else if(pid->read_elem)
|
|
{ error = 1; break; }
|
|
}
|
|
|
|
if(pm) {
|
|
BKE_ptcache_mem_incr_pointers(pm);
|
|
index = pm->data_types & (1<<BPHYS_DATA_INDEX) ? pm->cur[BPHYS_DATA_INDEX] : &i;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!error)
|
|
{
|
|
if(pf2 && pid->read_stream) {
|
|
if(totpoint2 != pid->totpoint(pid->calldata))
|
|
error = 1;
|
|
else
|
|
{
|
|
// we have stream writing here
|
|
pid->read_stream(pf2, pid->calldata);
|
|
}
|
|
}
|
|
}
|
|
|
|
totpoint2 = MIN2(totpoint2, pid->totpoint(pid->calldata));
|
|
|
|
if(!error)
|
|
{
|
|
for(i=0; i<totpoint2; i++) {
|
|
/* read old cache file format */
|
|
if(use_old) {
|
|
if(pid->read_elem && ptcache_file_read(pf2, (void*)old_data2, 1, old_elemsize)) {
|
|
if(!pf && pf2)
|
|
pid->read_elem(i, pid->calldata, NULL, frs_sec, (float)cfra2, old_data2);
|
|
else if(pid->interpolate_elem)
|
|
pid->interpolate_elem(i, pid->calldata, NULL, frs_sec, cfra, (float)cfra1, (float)cfra2, old_data2);
|
|
else
|
|
{ error = 1; break; }
|
|
}
|
|
else if(pid->read_elem)
|
|
{ error = 1; break; }
|
|
}
|
|
else {
|
|
if(pid->read_elem && (pm2 || ptcache_file_read_data(pf2))) {
|
|
if((!pf && pf2) || (!pm && pm2))
|
|
pid->read_elem(*index2, pid->calldata, pm2 ? pm2->cur : pf2->cur, frs_sec, (float)cfra2, NULL);
|
|
else if(pid->interpolate_elem)
|
|
pid->interpolate_elem(*index2, pid->calldata, pm2 ? pm2->cur : pf2->cur, frs_sec, cfra, (float)cfra1, (float)cfra2, NULL);
|
|
else
|
|
{ error = 1; break; }
|
|
}
|
|
else if(pid->read_elem)
|
|
{ error = 1; break; }
|
|
}
|
|
|
|
if(pm2) {
|
|
BKE_ptcache_mem_incr_pointers(pm2);
|
|
index2 = pm2->data_types & (1<<BPHYS_DATA_INDEX) ? pm2->cur[BPHYS_DATA_INDEX] : &i;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(pm || pf)
|
|
ret = (pm2 || pf2) ? PTCACHE_READ_INTERPOLATED : PTCACHE_READ_EXACT;
|
|
else if(pm2 || pf2) {
|
|
ret = PTCACHE_READ_OLD;
|
|
pid->cache->simframe = old_frame;
|
|
}
|
|
|
|
if(pf) {
|
|
ptcache_file_close(pf);
|
|
pf = NULL;
|
|
}
|
|
|
|
if(pf2) {
|
|
ptcache_file_close(pf2);
|
|
pf = NULL;
|
|
}
|
|
|
|
if((pid->cache->flag & PTCACHE_QUICK_CACHE)==0) {
|
|
cfrai = (int)cfra;
|
|
/* clear invalid cache frames so that better stuff can be simulated */
|
|
if(pid->cache->flag & PTCACHE_OUTDATED) {
|
|
BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_AFTER, cfrai);
|
|
}
|
|
else if(pid->cache->flag & PTCACHE_FRAMES_SKIPPED) {
|
|
if(cfra <= pid->cache->last_exact)
|
|
pid->cache->flag &= ~PTCACHE_FRAMES_SKIPPED;
|
|
|
|
BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_AFTER, MAX2(cfrai,pid->cache->last_exact));
|
|
}
|
|
}
|
|
|
|
return (error ? 0 : ret);
|
|
}
|
|
/* TODO for later */
|
|
//static void ptcache_make_index_array(PTCacheMem *pm, int totpoint)
|
|
//{
|
|
// int i, *index;
|
|
//
|
|
// if(pm->index_array) {
|
|
// MEM_freeN(pm->index_array);
|
|
// pm->index_array = NULL;
|
|
// }
|
|
//
|
|
// if(!pm->data[BPHYS_DATA_INDEX])
|
|
// return;
|
|
//
|
|
// pm->index_array = MEM_callocN(totpoint * sizeof(int), "PTCacheMem index_array");
|
|
// index = pm->data[BPHYS_DATA_INDEX];
|
|
//
|
|
// for(i=0; i<pm->totpoint; i++, index++)
|
|
// pm->index_array[*index] = i;
|
|
//}
|
|
/* writes cache to disk or memory */
|
|
int BKE_ptcache_write_cache(PTCacheID *pid, int cfra)
|
|
{
|
|
PointCache *cache = pid->cache;
|
|
PTCacheFile *pf= NULL;
|
|
int i;
|
|
int totpoint = pid->totpoint(pid->calldata);
|
|
int add = 0, overwrite = 0;
|
|
|
|
if(totpoint == 0 || cfra < 0
|
|
|| (cfra ? pid->data_types == 0 : pid->info_types == 0))
|
|
return 0;
|
|
|
|
if(cache->flag & PTCACHE_DISK_CACHE) {
|
|
int efra = cache->endframe;
|
|
|
|
if(cfra==0)
|
|
add = 1;
|
|
/* allways start from scratch on the first frame */
|
|
else if(cfra == cache->startframe) {
|
|
BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_ALL, cfra);
|
|
cache->flag &= ~PTCACHE_REDO_NEEDED;
|
|
add = 1;
|
|
}
|
|
else {
|
|
int ofra;
|
|
/* find last cached frame */
|
|
while(efra > cache->startframe && !BKE_ptcache_id_exist(pid, efra))
|
|
efra--;
|
|
|
|
/* find second last cached frame */
|
|
ofra = efra-1;
|
|
while(ofra > cache->startframe && !BKE_ptcache_id_exist(pid, ofra))
|
|
ofra--;
|
|
|
|
if(efra >= cache->startframe && cfra > efra) {
|
|
if(ofra >= cache->startframe && efra - ofra < cache->step)
|
|
overwrite = 1;
|
|
else
|
|
add = 1;
|
|
}
|
|
}
|
|
|
|
if(add || overwrite) {
|
|
if(overwrite)
|
|
BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_FRAME, efra);
|
|
|
|
pf = ptcache_file_open(pid, PTCACHE_FILE_WRITE, cfra);
|
|
if(!pf)
|
|
return 0;
|
|
|
|
pf->type = pid->type;
|
|
pf->totpoint = cfra ? totpoint : pid->totwrite(pid->calldata);
|
|
pf->data_types = cfra ? pid->data_types : pid->info_types;
|
|
|
|
if(!ptcache_file_write_header_begin(pf) || !pid->write_header(pf)) {
|
|
ptcache_file_close(pf);
|
|
return 0;
|
|
}
|
|
|
|
ptcache_file_init_pointers(pf);
|
|
|
|
if(pf && pid->write_stream) {
|
|
// we have stream writing here
|
|
pid->write_stream(pf, pid->calldata);
|
|
}
|
|
else
|
|
for(i=0; i<totpoint; i++) {
|
|
if(pid->write_elem && pid->write_elem(i, pid->calldata, pf->cur))
|
|
if(!ptcache_file_write_data(pf)) {
|
|
ptcache_file_close(pf);
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
PTCacheMem *pm;
|
|
PTCacheMem *pm2;
|
|
|
|
pm2 = cache->mem_cache.first;
|
|
|
|
/* don't write info file in memory */
|
|
if(cfra==0)
|
|
return 1;
|
|
/* allways start from scratch on the first frame */
|
|
if(cfra == cache->startframe) {
|
|
BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_ALL, cfra);
|
|
cache->flag &= ~PTCACHE_REDO_NEEDED;
|
|
add = 1;
|
|
}
|
|
else if (cache->mem_cache.last) {
|
|
pm2 = cache->mem_cache.last;
|
|
|
|
if(pm2 && cfra > pm2->frame) {
|
|
if(pm2->prev && pm2->frame - pm2->prev->frame < cache->step)
|
|
overwrite = 1;
|
|
else
|
|
add = 1;
|
|
}
|
|
}
|
|
else
|
|
add = 1;
|
|
|
|
if(add || overwrite) {
|
|
if(overwrite)
|
|
BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_FRAME, pm2->frame);
|
|
|
|
pm = MEM_callocN(sizeof(PTCacheMem), "Pointcache mem");
|
|
|
|
pm->totpoint = pid->totwrite(pid->calldata);
|
|
pm->data_types = cfra ? pid->data_types : pid->info_types;
|
|
|
|
ptcache_alloc_data(pm);
|
|
BKE_ptcache_mem_init_pointers(pm);
|
|
|
|
for(i=0; i<totpoint; i++) {
|
|
if(pid->write_elem && pid->write_elem(i, pid->calldata, pm->cur))
|
|
BKE_ptcache_mem_incr_pointers(pm);
|
|
}
|
|
//ptcache_make_index_array(pm, pid->totpoint(pid->calldata));
|
|
|
|
pm->frame = cfra;
|
|
BLI_addtail(&cache->mem_cache, pm);
|
|
}
|
|
}
|
|
|
|
if(add || overwrite) {
|
|
if(cfra - cache->last_exact == 1
|
|
|| cfra == cache->startframe) {
|
|
cache->last_exact = cfra;
|
|
cache->flag &= ~PTCACHE_FRAMES_SKIPPED;
|
|
}
|
|
else
|
|
cache->flag |= PTCACHE_FRAMES_SKIPPED;
|
|
}
|
|
|
|
if(pf)
|
|
ptcache_file_close(pf);
|
|
|
|
BKE_ptcache_update_info(pid);
|
|
|
|
return 1;
|
|
}
|
|
/* youll need to close yourself after!
|
|
* mode - PTCACHE_CLEAR_ALL,
|
|
|
|
*/
|
|
/* Clears & resets */
|
|
void BKE_ptcache_id_clear(PTCacheID *pid, int mode, int cfra)
|
|
{
|
|
int len; /* store the length of the string */
|
|
|
|
/* mode is same as fopen's modes */
|
|
DIR *dir;
|
|
struct dirent *de;
|
|
char path[MAX_PTCACHE_PATH];
|
|
char filename[MAX_PTCACHE_FILE];
|
|
char path_full[MAX_PTCACHE_FILE];
|
|
char ext[MAX_PTCACHE_PATH];
|
|
|
|
if(!pid->cache || pid->cache->flag & PTCACHE_BAKED)
|
|
return;
|
|
|
|
/* don't allow clearing for linked objects */
|
|
if(pid->ob->id.lib)
|
|
return;
|
|
|
|
/*if (!G.relbase_valid) return; *//* save blend file before using pointcache */
|
|
|
|
/* clear all files in the temp dir with the prefix of the ID and the ".bphys" suffix */
|
|
switch (mode) {
|
|
case PTCACHE_CLEAR_ALL:
|
|
case PTCACHE_CLEAR_BEFORE:
|
|
case PTCACHE_CLEAR_AFTER:
|
|
if(pid->cache->flag & PTCACHE_DISK_CACHE) {
|
|
ptcache_path(pid, path);
|
|
|
|
len = BKE_ptcache_id_filename(pid, filename, cfra, 0, 0); /* no path */
|
|
|
|
dir = opendir(path);
|
|
if (dir==NULL)
|
|
return;
|
|
|
|
snprintf(ext, sizeof(ext), "_%02d"PTCACHE_EXT, pid->stack_index);
|
|
|
|
while ((de = readdir(dir)) != NULL) {
|
|
if (strstr(de->d_name, ext)) { /* do we have the right extension?*/
|
|
if (strncmp(filename, de->d_name, len ) == 0) { /* do we have the right prefix */
|
|
if (mode == PTCACHE_CLEAR_ALL) {
|
|
pid->cache->last_exact = 0;
|
|
BLI_join_dirfile(path_full, path, de->d_name);
|
|
BLI_delete(path_full, 0, 0);
|
|
} else {
|
|
/* read the number of the file */
|
|
int frame, len2 = (int)strlen(de->d_name);
|
|
char num[7];
|
|
|
|
if (len2 > 15) { /* could crash if trying to copy a string out of this range*/
|
|
BLI_strncpy(num, de->d_name + (strlen(de->d_name) - 15), sizeof(num));
|
|
frame = atoi(num);
|
|
|
|
if((mode==PTCACHE_CLEAR_BEFORE && frame < cfra) ||
|
|
(mode==PTCACHE_CLEAR_AFTER && frame > cfra) ) {
|
|
|
|
BLI_join_dirfile(path_full, path, de->d_name);
|
|
BLI_delete(path_full, 0, 0);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
closedir(dir);
|
|
}
|
|
else {
|
|
PTCacheMem *pm= pid->cache->mem_cache.first;
|
|
PTCacheMem *link= NULL;
|
|
|
|
pm= pid->cache->mem_cache.first;
|
|
|
|
if(mode == PTCACHE_CLEAR_ALL) {
|
|
pid->cache->last_exact = 0;
|
|
for(; pm; pm=pm->next)
|
|
ptcache_free_data(pm->data);
|
|
BLI_freelistN(&pid->cache->mem_cache);
|
|
} else {
|
|
while(pm) {
|
|
if((mode==PTCACHE_CLEAR_BEFORE && pm->frame < cfra) ||
|
|
(mode==PTCACHE_CLEAR_AFTER && pm->frame > cfra) ) {
|
|
link = pm;
|
|
pm = pm->next;
|
|
ptcache_free_data(link->data);
|
|
BLI_freelinkN(&pid->cache->mem_cache, link);
|
|
}
|
|
else
|
|
pm = pm->next;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case PTCACHE_CLEAR_FRAME:
|
|
if(pid->cache->flag & PTCACHE_DISK_CACHE) {
|
|
if(BKE_ptcache_id_exist(pid, cfra)) {
|
|
BKE_ptcache_id_filename(pid, filename, cfra, 1, 1); /* no path */
|
|
BLI_delete(filename, 0, 0);
|
|
}
|
|
}
|
|
else {
|
|
PTCacheMem *pm = pid->cache->mem_cache.first;
|
|
|
|
for(; pm; pm=pm->next) {
|
|
if(pm->frame == cfra) {
|
|
ptcache_free_data(pm->data);
|
|
BLI_freelinkN(&pid->cache->mem_cache, pm);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
BKE_ptcache_update_info(pid);
|
|
}
|
|
|
|
int BKE_ptcache_id_exist(PTCacheID *pid, int cfra)
|
|
{
|
|
if(!pid->cache)
|
|
return 0;
|
|
|
|
if(pid->cache->flag & PTCACHE_DISK_CACHE) {
|
|
char filename[MAX_PTCACHE_FILE];
|
|
|
|
BKE_ptcache_id_filename(pid, filename, cfra, 1, 1);
|
|
|
|
return BLI_exists(filename);
|
|
}
|
|
else {
|
|
PTCacheMem *pm = pid->cache->mem_cache.first;
|
|
|
|
for(; pm; pm=pm->next) {
|
|
if(pm->frame==cfra)
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
void BKE_ptcache_id_time(PTCacheID *pid, Scene *scene, float cfra, int *startframe, int *endframe, float *timescale)
|
|
{
|
|
Object *ob;
|
|
PointCache *cache;
|
|
float offset, time, nexttime;
|
|
|
|
/* TODO: this has to be sorter out once bsystem_time gets redone, */
|
|
/* now caches can handle interpolating etc. too - jahka */
|
|
|
|
/* time handling for point cache:
|
|
* - simulation time is scaled by result of bsystem_time
|
|
* - for offsetting time only time offset is taken into account, since
|
|
* that's always the same and can't be animated. a timeoffset which
|
|
* varies over time is not simpe to support.
|
|
* - field and motion blur offsets are currently ignored, proper solution
|
|
* is probably to interpolate results from two frames for that ..
|
|
*/
|
|
|
|
ob= pid->ob;
|
|
cache= pid->cache;
|
|
|
|
if(timescale) {
|
|
time= bsystem_time(scene, ob, cfra, 0.0f);
|
|
nexttime= bsystem_time(scene, ob, cfra+1.0f, 0.0f);
|
|
|
|
*timescale= MAX2(nexttime - time, 0.0f);
|
|
}
|
|
|
|
if(startframe && endframe) {
|
|
*startframe= cache->startframe;
|
|
*endframe= cache->endframe;
|
|
|
|
// XXX ipoflag is depreceated - old animation system stuff
|
|
if (/*(ob->ipoflag & OB_OFFS_PARENT) &&*/ (ob->partype & PARSLOW)==0) {
|
|
offset= give_timeoffset(ob);
|
|
|
|
*startframe += (int)(offset+0.5f);
|
|
*endframe += (int)(offset+0.5f);
|
|
}
|
|
}
|
|
}
|
|
|
|
int BKE_ptcache_id_reset(Scene *scene, PTCacheID *pid, int mode)
|
|
{
|
|
PointCache *cache;
|
|
int reset, clear, after;
|
|
|
|
if(!pid->cache)
|
|
return 0;
|
|
|
|
cache= pid->cache;
|
|
reset= 0;
|
|
clear= 0;
|
|
after= 0;
|
|
|
|
if(mode == PTCACHE_RESET_DEPSGRAPH) {
|
|
if(!(cache->flag & PTCACHE_BAKED) && !BKE_ptcache_get_continue_physics()) {
|
|
if(cache->flag & PTCACHE_QUICK_CACHE)
|
|
clear= 1;
|
|
|
|
after= 1;
|
|
}
|
|
|
|
cache->flag |= PTCACHE_OUTDATED;
|
|
}
|
|
else if(mode == PTCACHE_RESET_BAKED) {
|
|
if(!BKE_ptcache_get_continue_physics()) {
|
|
reset= 1;
|
|
clear= 1;
|
|
}
|
|
else
|
|
cache->flag |= PTCACHE_OUTDATED;
|
|
}
|
|
else if(mode == PTCACHE_RESET_OUTDATED) {
|
|
reset = 1;
|
|
|
|
if(cache->flag & PTCACHE_OUTDATED)
|
|
if(!(cache->flag & PTCACHE_BAKED))
|
|
clear= 1;
|
|
}
|
|
|
|
if(reset) {
|
|
cache->flag &= ~(PTCACHE_REDO_NEEDED|PTCACHE_SIMULATION_VALID);
|
|
cache->simframe= 0;
|
|
cache->last_exact= 0;
|
|
|
|
if(pid->type == PTCACHE_TYPE_CLOTH)
|
|
cloth_free_modifier(pid->ob, pid->calldata);
|
|
else if(pid->type == PTCACHE_TYPE_SOFTBODY)
|
|
sbFreeSimulation(pid->calldata);
|
|
else if(pid->type == PTCACHE_TYPE_PARTICLES)
|
|
psys_reset(pid->calldata, PSYS_RESET_DEPSGRAPH);
|
|
else if(pid->type == PTCACHE_TYPE_SMOKE_DOMAIN)
|
|
smokeModifier_reset(pid->calldata);
|
|
}
|
|
if(clear)
|
|
BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_ALL, 0);
|
|
else if(after)
|
|
BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_AFTER, CFRA);
|
|
|
|
return (reset || clear || after);
|
|
}
|
|
|
|
int BKE_ptcache_object_reset(Scene *scene, Object *ob, int mode)
|
|
{
|
|
PTCacheID pid;
|
|
ParticleSystem *psys;
|
|
ModifierData *md;
|
|
int reset, skip;
|
|
|
|
reset= 0;
|
|
skip= 0;
|
|
|
|
if(ob->soft) {
|
|
BKE_ptcache_id_from_softbody(&pid, ob, ob->soft);
|
|
reset |= BKE_ptcache_id_reset(scene, &pid, mode);
|
|
}
|
|
|
|
for(psys=ob->particlesystem.first; psys; psys=psys->next) {
|
|
/* Baked softbody hair has to be checked first, because we don't want to reset */
|
|
/* particles or softbody in that case -jahka */
|
|
if(psys->soft) {
|
|
BKE_ptcache_id_from_softbody(&pid, ob, psys->soft);
|
|
if(mode == PSYS_RESET_ALL || !(psys->part->type == PART_HAIR && (pid.cache->flag & PTCACHE_BAKED)))
|
|
reset |= BKE_ptcache_id_reset(scene, &pid, mode);
|
|
else
|
|
skip = 1;
|
|
}
|
|
else if(psys->recalc & PSYS_RECALC_REDO || psys->recalc & PSYS_RECALC_CHILD)
|
|
skip = 1;
|
|
|
|
if(skip == 0 && psys->part) {
|
|
BKE_ptcache_id_from_particles(&pid, ob, psys);
|
|
reset |= BKE_ptcache_id_reset(scene, &pid, mode);
|
|
}
|
|
}
|
|
|
|
for(md=ob->modifiers.first; md; md=md->next) {
|
|
if(md->type == eModifierType_Cloth) {
|
|
BKE_ptcache_id_from_cloth(&pid, ob, (ClothModifierData*)md);
|
|
reset |= BKE_ptcache_id_reset(scene, &pid, mode);
|
|
}
|
|
if(md->type == eModifierType_Smoke) {
|
|
SmokeModifierData *smd = (SmokeModifierData *)md;
|
|
if(smd->type & MOD_SMOKE_TYPE_DOMAIN)
|
|
{
|
|
BKE_ptcache_id_from_smoke(&pid, ob, (SmokeModifierData*)md);
|
|
reset |= BKE_ptcache_id_reset(scene, &pid, mode);
|
|
}
|
|
}
|
|
}
|
|
|
|
return reset;
|
|
}
|
|
|
|
/* Use this when quitting blender, with unsaved files */
|
|
void BKE_ptcache_remove(void)
|
|
{
|
|
char path[MAX_PTCACHE_PATH];
|
|
char path_full[MAX_PTCACHE_PATH];
|
|
int rmdir = 1;
|
|
|
|
ptcache_path(NULL, path);
|
|
|
|
if (BLI_exist(path)) {
|
|
/* The pointcache dir exists? - remove all pointcache */
|
|
|
|
DIR *dir;
|
|
struct dirent *de;
|
|
|
|
dir = opendir(path);
|
|
if (dir==NULL)
|
|
return;
|
|
|
|
while ((de = readdir(dir)) != NULL) {
|
|
if( strcmp(de->d_name, ".")==0 || strcmp(de->d_name, "..")==0) {
|
|
/* do nothing */
|
|
} else if (strstr(de->d_name, PTCACHE_EXT)) { /* do we have the right extension?*/
|
|
BLI_join_dirfile(path_full, path, de->d_name);
|
|
BLI_delete(path_full, 0, 0);
|
|
} else {
|
|
rmdir = 0; /* unknown file, dont remove the dir */
|
|
}
|
|
}
|
|
|
|
closedir(dir);
|
|
} else {
|
|
rmdir = 0; /* path dosnt exist */
|
|
}
|
|
|
|
if (rmdir) {
|
|
BLI_delete(path, 1, 0);
|
|
}
|
|
}
|
|
|
|
/* Continuous Interaction */
|
|
|
|
static int CONTINUE_PHYSICS = 0;
|
|
|
|
void BKE_ptcache_set_continue_physics(Scene *scene, int enable)
|
|
{
|
|
Object *ob;
|
|
|
|
if(CONTINUE_PHYSICS != enable) {
|
|
CONTINUE_PHYSICS = enable;
|
|
|
|
if(CONTINUE_PHYSICS == 0) {
|
|
for(ob=G.main->object.first; ob; ob=ob->id.next)
|
|
if(BKE_ptcache_object_reset(scene, ob, PTCACHE_RESET_OUTDATED))
|
|
DAG_object_flush_update(scene, ob, OB_RECALC_DATA);
|
|
}
|
|
}
|
|
}
|
|
|
|
int BKE_ptcache_get_continue_physics()
|
|
{
|
|
return CONTINUE_PHYSICS;
|
|
}
|
|
|
|
/* Point Cache handling */
|
|
|
|
PointCache *BKE_ptcache_add(ListBase *ptcaches)
|
|
{
|
|
PointCache *cache;
|
|
|
|
cache= MEM_callocN(sizeof(PointCache), "PointCache");
|
|
cache->startframe= 1;
|
|
cache->endframe= 250;
|
|
cache->step= 10;
|
|
cache->index = -1;
|
|
|
|
BLI_addtail(ptcaches, cache);
|
|
|
|
return cache;
|
|
}
|
|
|
|
void BKE_ptcache_free_mem(ListBase *mem_cache)
|
|
{
|
|
PTCacheMem *pm = mem_cache->first;
|
|
|
|
if(pm) {
|
|
for(; pm; pm=pm->next) {
|
|
ptcache_free_data(pm->data);
|
|
if(pm->index_array)
|
|
MEM_freeN(pm->index_array);
|
|
}
|
|
|
|
BLI_freelistN(mem_cache);
|
|
}
|
|
}
|
|
void BKE_ptcache_free(PointCache *cache)
|
|
{
|
|
BKE_ptcache_free_mem(&cache->mem_cache);
|
|
if(cache->edit && cache->free_edit)
|
|
cache->free_edit(cache->edit);
|
|
MEM_freeN(cache);
|
|
}
|
|
void BKE_ptcache_free_list(ListBase *ptcaches)
|
|
{
|
|
PointCache *cache = ptcaches->first;
|
|
|
|
while(cache) {
|
|
BLI_remlink(ptcaches, cache);
|
|
BKE_ptcache_free(cache);
|
|
cache = ptcaches->first;
|
|
}
|
|
}
|
|
|
|
static PointCache *ptcache_copy(PointCache *cache)
|
|
{
|
|
PointCache *ncache;
|
|
|
|
ncache= MEM_dupallocN(cache);
|
|
|
|
/* hmm, should these be copied over instead? */
|
|
ncache->mem_cache.first = NULL;
|
|
ncache->mem_cache.last = NULL;
|
|
|
|
ncache->flag= 0;
|
|
ncache->simframe= 0;
|
|
|
|
return ncache;
|
|
}
|
|
/* returns first point cache */
|
|
PointCache *BKE_ptcache_copy_list(ListBase *ptcaches_new, ListBase *ptcaches_old)
|
|
{
|
|
PointCache *cache = ptcaches_old->first;
|
|
|
|
ptcaches_new->first = ptcaches_new->last = NULL;
|
|
|
|
for(; cache; cache=cache->next)
|
|
BLI_addtail(ptcaches_new, ptcache_copy(cache));
|
|
|
|
return ptcaches_new->first;
|
|
}
|
|
|
|
|
|
/* Baking */
|
|
static int count_quick_cache(Scene *scene, int *quick_step)
|
|
{
|
|
Base *base = scene->base.first;
|
|
PTCacheID *pid;
|
|
ListBase pidlist;
|
|
int autocache_count= 0;
|
|
|
|
for(base = scene->base.first; base; base = base->next) {
|
|
if(base->object) {
|
|
BKE_ptcache_ids_from_object(&pidlist, base->object);
|
|
|
|
for(pid=pidlist.first; pid; pid=pid->next) {
|
|
if((pid->cache->flag & PTCACHE_BAKED)
|
|
|| (pid->cache->flag & PTCACHE_QUICK_CACHE)==0)
|
|
continue;
|
|
|
|
if(pid->cache->flag & PTCACHE_OUTDATED || (pid->cache->flag & PTCACHE_SIMULATION_VALID)==0) {
|
|
if(!autocache_count)
|
|
*quick_step = pid->cache->step;
|
|
else
|
|
*quick_step = MIN2(*quick_step, pid->cache->step);
|
|
|
|
autocache_count++;
|
|
}
|
|
}
|
|
|
|
BLI_freelistN(&pidlist);
|
|
}
|
|
}
|
|
|
|
return autocache_count;
|
|
}
|
|
void BKE_ptcache_quick_cache_all(Scene *scene)
|
|
{
|
|
PTCacheBaker baker;
|
|
|
|
baker.bake=0;
|
|
baker.break_data=NULL;
|
|
baker.break_test=NULL;
|
|
baker.pid=NULL;
|
|
baker.progressbar=NULL;
|
|
baker.progresscontext=NULL;
|
|
baker.render=0;
|
|
baker.anim_init = 0;
|
|
baker.scene=scene;
|
|
|
|
if(count_quick_cache(scene, &baker.quick_step))
|
|
BKE_ptcache_make_cache(&baker);
|
|
}
|
|
|
|
/* if bake is not given run simulations to current frame */
|
|
void BKE_ptcache_make_cache(PTCacheBaker* baker)
|
|
{
|
|
Scene *scene = baker->scene;
|
|
Base *base;
|
|
ListBase pidlist;
|
|
PTCacheID *pid = baker->pid;
|
|
PointCache *cache = NULL;
|
|
float frameleno = scene->r.framelen;
|
|
int cfrao = CFRA;
|
|
int startframe = MAXFRAME;
|
|
int endframe = baker->anim_init ? scene->r.sfra : CFRA;
|
|
int bake = baker->bake;
|
|
int render = baker->render;
|
|
int step = baker->quick_step;
|
|
|
|
G.afbreek = 0;
|
|
|
|
/* set caches to baking mode and figure out start frame */
|
|
if(pid) {
|
|
/* cache/bake a single object */
|
|
cache = pid->cache;
|
|
if((cache->flag & PTCACHE_BAKED)==0) {
|
|
if(pid->type==PTCACHE_TYPE_PARTICLES)
|
|
psys_get_pointcache_start_end(scene, pid->calldata, &cache->startframe, &cache->endframe);
|
|
|
|
if(bake || cache->flag & PTCACHE_REDO_NEEDED)
|
|
BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_ALL, 0);
|
|
|
|
startframe = MAX2(cache->last_exact, cache->startframe);
|
|
|
|
if(bake) {
|
|
endframe = cache->endframe;
|
|
cache->flag |= PTCACHE_BAKING;
|
|
}
|
|
else {
|
|
endframe = MIN2(endframe, cache->endframe);
|
|
}
|
|
|
|
cache->flag &= ~PTCACHE_BAKED;
|
|
}
|
|
}
|
|
else for(base=scene->base.first; base; base= base->next) {
|
|
/* cache/bake everything in the scene */
|
|
BKE_ptcache_ids_from_object(&pidlist, base->object);
|
|
|
|
for(pid=pidlist.first; pid; pid=pid->next) {
|
|
cache = pid->cache;
|
|
if((cache->flag & PTCACHE_BAKED)==0) {
|
|
if(pid->type==PTCACHE_TYPE_PARTICLES) {
|
|
ParticleSystem *psys = (ParticleSystem*)pid->calldata;
|
|
/* skip hair & keyed particles */
|
|
if(psys->part->type == PART_HAIR || psys->part->phystype == PART_PHYS_KEYED)
|
|
continue;
|
|
|
|
psys_get_pointcache_start_end(scene, pid->calldata, &cache->startframe, &cache->endframe);
|
|
}
|
|
|
|
if((cache->flag & PTCACHE_REDO_NEEDED || (cache->flag & PTCACHE_SIMULATION_VALID)==0)
|
|
&& ((cache->flag & PTCACHE_QUICK_CACHE)==0 || render || bake))
|
|
BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_ALL, 0);
|
|
|
|
startframe = MIN2(startframe, cache->startframe);
|
|
|
|
if(bake || render) {
|
|
cache->flag |= PTCACHE_BAKING;
|
|
|
|
if(bake)
|
|
endframe = MAX2(endframe, cache->endframe);
|
|
}
|
|
|
|
cache->flag &= ~PTCACHE_BAKED;
|
|
|
|
}
|
|
}
|
|
BLI_freelistN(&pidlist);
|
|
}
|
|
|
|
CFRA= startframe;
|
|
scene->r.framelen = 1.0;
|
|
|
|
for(; CFRA <= endframe; CFRA+=step) {
|
|
int prog;
|
|
|
|
if(bake)
|
|
prog = (int)(100.0f * (float)(CFRA - startframe)/(float)(endframe-startframe));
|
|
else
|
|
prog = CFRA;
|
|
|
|
/* NOTE: baking should not redraw whole ui as this slows things down */
|
|
if(baker->progressbar)
|
|
baker->progressbar(baker->progresscontext, prog);
|
|
|
|
scene_update_for_newframe(scene, scene->lay);
|
|
|
|
/* NOTE: breaking baking should leave calculated frames in cache, not clear it */
|
|
if(baker->break_test && baker->break_test(baker->break_data))
|
|
break;
|
|
}
|
|
|
|
/* clear baking flag */
|
|
if(pid) {
|
|
cache->flag &= ~(PTCACHE_BAKING|PTCACHE_REDO_NEEDED);
|
|
cache->flag |= PTCACHE_SIMULATION_VALID;
|
|
if(bake) {
|
|
cache->flag |= PTCACHE_BAKED;
|
|
/* write info file */
|
|
if(cache->flag & PTCACHE_DISK_CACHE)
|
|
BKE_ptcache_write_cache(pid, 0);
|
|
}
|
|
}
|
|
else for(base=scene->base.first; base; base= base->next) {
|
|
BKE_ptcache_ids_from_object(&pidlist, base->object);
|
|
|
|
for(pid=pidlist.first; pid; pid=pid->next) {
|
|
/* skip hair particles */
|
|
if(pid->type==PTCACHE_TYPE_PARTICLES && ((ParticleSystem*)pid->calldata)->part->type == PART_HAIR)
|
|
continue;
|
|
|
|
cache = pid->cache;
|
|
|
|
if(step > 1)
|
|
cache->flag &= ~(PTCACHE_BAKING|PTCACHE_OUTDATED);
|
|
else
|
|
cache->flag &= ~(PTCACHE_BAKING|PTCACHE_REDO_NEEDED);
|
|
|
|
cache->flag |= PTCACHE_SIMULATION_VALID;
|
|
|
|
if(bake) {
|
|
cache->flag |= PTCACHE_BAKED;
|
|
if(cache->flag & PTCACHE_DISK_CACHE)
|
|
BKE_ptcache_write_cache(pid, 0);
|
|
}
|
|
}
|
|
BLI_freelistN(&pidlist);
|
|
}
|
|
|
|
scene->r.framelen = frameleno;
|
|
CFRA = cfrao;
|
|
|
|
if(bake) /* already on cfra unless baking */
|
|
scene_update_for_newframe(scene, scene->lay);
|
|
|
|
/* TODO: call redraw all windows somehow */
|
|
}
|
|
/* Helpers */
|
|
void BKE_ptcache_disk_to_mem(PTCacheID *pid)
|
|
{
|
|
PointCache *cache = pid->cache;
|
|
PTCacheFile *pf;
|
|
PTCacheMem *pm;
|
|
|
|
int cfra, sfra = cache->startframe, efra = cache->endframe;
|
|
int i;
|
|
|
|
BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_ALL, 0);
|
|
|
|
for(cfra=sfra; cfra <= efra; cfra++) {
|
|
pf = ptcache_file_open(pid, PTCACHE_FILE_READ, cfra);
|
|
|
|
if(pf) {
|
|
if(!ptcache_file_read_header_begin(pf)) {
|
|
printf("Can't yet convert old cache format\n");
|
|
cache->flag |= PTCACHE_DISK_CACHE;
|
|
ptcache_file_close(pf);
|
|
return;
|
|
}
|
|
|
|
if(pf->type != pid->type || !pid->read_header(pf)) {
|
|
cache->flag |= PTCACHE_DISK_CACHE;
|
|
ptcache_file_close(pf);
|
|
return;
|
|
}
|
|
|
|
pm = MEM_callocN(sizeof(PTCacheMem), "Pointcache mem");
|
|
|
|
pm->totpoint = pf->totpoint;
|
|
pm->data_types = pf->data_types;
|
|
pm->frame = cfra;
|
|
|
|
ptcache_alloc_data(pm);
|
|
BKE_ptcache_mem_init_pointers(pm);
|
|
ptcache_file_init_pointers(pf);
|
|
|
|
for(i=0; i<pm->totpoint; i++) {
|
|
if(!ptcache_file_read_data(pf)) {
|
|
printf("Error reading from disk cache\n");
|
|
|
|
cache->flag |= PTCACHE_DISK_CACHE;
|
|
|
|
ptcache_free_data(pm->data);
|
|
MEM_freeN(pm);
|
|
ptcache_file_close(pf);
|
|
|
|
return;
|
|
}
|
|
ptcache_copy_data(pf->cur, pm->cur);
|
|
BKE_ptcache_mem_incr_pointers(pm);
|
|
}
|
|
|
|
//ptcache_make_index_array(pm, pid->totpoint(pid->calldata));
|
|
|
|
BLI_addtail(&pid->cache->mem_cache, pm);
|
|
|
|
ptcache_file_close(pf);
|
|
}
|
|
}
|
|
|
|
}
|
|
void BKE_ptcache_mem_to_disk(PTCacheID *pid)
|
|
{
|
|
PointCache *cache = pid->cache;
|
|
PTCacheFile *pf;
|
|
PTCacheMem *pm;
|
|
int i;
|
|
|
|
pm = cache->mem_cache.first;
|
|
|
|
BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_ALL, 0);
|
|
|
|
for(; pm; pm=pm->next) {
|
|
pf = ptcache_file_open(pid, PTCACHE_FILE_WRITE, pm->frame);
|
|
|
|
if(pf) {
|
|
pf->data_types = pm->data_types;
|
|
pf->totpoint = pm->totpoint;
|
|
pf->type = pid->type;
|
|
|
|
BKE_ptcache_mem_init_pointers(pm);
|
|
ptcache_file_init_pointers(pf);
|
|
|
|
if(!ptcache_file_write_header_begin(pf) || !pid->write_header(pf)) {
|
|
printf("Error writing to disk cache\n");
|
|
cache->flag &= ~PTCACHE_DISK_CACHE;
|
|
|
|
ptcache_file_close(pf);
|
|
return;
|
|
}
|
|
|
|
for(i=0; i<pm->totpoint; i++) {
|
|
ptcache_copy_data(pm->cur, pf->cur);
|
|
if(!ptcache_file_write_data(pf)) {
|
|
printf("Error writing to disk cache\n");
|
|
cache->flag &= ~PTCACHE_DISK_CACHE;
|
|
|
|
ptcache_file_close(pf);
|
|
return;
|
|
}
|
|
BKE_ptcache_mem_incr_pointers(pm);
|
|
}
|
|
|
|
ptcache_file_close(pf);
|
|
|
|
/* write info file */
|
|
if(cache->flag & PTCACHE_BAKED)
|
|
BKE_ptcache_write_cache(pid, 0);
|
|
}
|
|
else
|
|
printf("Error creating disk cache file\n");
|
|
}
|
|
}
|
|
void BKE_ptcache_toggle_disk_cache(PTCacheID *pid)
|
|
{
|
|
PointCache *cache = pid->cache;
|
|
int last_exact = cache->last_exact;
|
|
|
|
if (!G.relbase_valid){
|
|
cache->flag &= ~PTCACHE_DISK_CACHE;
|
|
printf("File must be saved before using disk cache!\n");
|
|
return;
|
|
}
|
|
|
|
if(cache->flag & PTCACHE_DISK_CACHE)
|
|
BKE_ptcache_mem_to_disk(pid);
|
|
else
|
|
BKE_ptcache_disk_to_mem(pid);
|
|
|
|
cache->flag ^= PTCACHE_DISK_CACHE;
|
|
BKE_ptcache_id_clear(pid, PTCACHE_CLEAR_ALL, 0);
|
|
cache->flag ^= PTCACHE_DISK_CACHE;
|
|
|
|
cache->last_exact = last_exact;
|
|
|
|
BKE_ptcache_update_info(pid);
|
|
}
|
|
|
|
void BKE_ptcache_load_external(PTCacheID *pid)
|
|
{
|
|
/*todo*/
|
|
PointCache *cache = pid->cache;
|
|
int len; /* store the length of the string */
|
|
int info = 0;
|
|
|
|
/* mode is same as fopen's modes */
|
|
DIR *dir;
|
|
struct dirent *de;
|
|
char path[MAX_PTCACHE_PATH];
|
|
char filename[MAX_PTCACHE_FILE];
|
|
char ext[MAX_PTCACHE_PATH];
|
|
|
|
if(!cache)
|
|
return;
|
|
|
|
cache->startframe = MAXFRAME;
|
|
cache->endframe = -1;
|
|
cache->totpoint = 0;
|
|
|
|
ptcache_path(pid, path);
|
|
|
|
len = BKE_ptcache_id_filename(pid, filename, 1, 0, 0); /* no path */
|
|
|
|
dir = opendir(path);
|
|
if (dir==NULL)
|
|
return;
|
|
|
|
if(cache->index >= 0)
|
|
snprintf(ext, sizeof(ext), "_%02d"PTCACHE_EXT, cache->index);
|
|
else
|
|
strcpy(ext, PTCACHE_EXT);
|
|
|
|
while ((de = readdir(dir)) != NULL) {
|
|
if (strstr(de->d_name, ext)) { /* do we have the right extension?*/
|
|
if (strncmp(filename, de->d_name, len ) == 0) { /* do we have the right prefix */
|
|
/* read the number of the file */
|
|
int frame, len2 = (int)strlen(de->d_name);
|
|
char num[7];
|
|
|
|
if (len2 > 15) { /* could crash if trying to copy a string out of this range*/
|
|
BLI_strncpy(num, de->d_name + (strlen(de->d_name) - 15), sizeof(num));
|
|
frame = atoi(num);
|
|
|
|
if(frame) {
|
|
cache->startframe = MIN2(cache->startframe, frame);
|
|
cache->endframe = MAX2(cache->endframe, frame);
|
|
}
|
|
else
|
|
info = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
closedir(dir);
|
|
|
|
if(cache->startframe != MAXFRAME) {
|
|
PTCacheFile *pf;
|
|
|
|
/* read totpoint from info file (frame 0) */
|
|
if(info) {
|
|
pf= ptcache_file_open(pid, PTCACHE_FILE_READ, 0);
|
|
|
|
if(pf) {
|
|
if(ptcache_file_read_header_begin(pf)) {
|
|
if(pf->type == pid->type && pid->read_header(pf)) {
|
|
cache->totpoint = pf->totpoint;
|
|
cache->flag |= PTCACHE_READ_INFO;
|
|
}
|
|
else {
|
|
cache->totpoint = 0;
|
|
}
|
|
}
|
|
ptcache_file_close(pf);
|
|
}
|
|
}
|
|
/* or from any old format cache file */
|
|
else {
|
|
float old_data[14];
|
|
int elemsize = ptcache_pid_old_elemsize(pid);
|
|
pf= ptcache_file_open(pid, PTCACHE_FILE_READ, cache->startframe);
|
|
|
|
if(pf) {
|
|
while(ptcache_file_read(pf, old_data, 1, elemsize))
|
|
cache->totpoint++;
|
|
|
|
ptcache_file_close(pf);
|
|
}
|
|
}
|
|
}
|
|
|
|
cache->flag &= ~(PTCACHE_OUTDATED|PTCACHE_FRAMES_SKIPPED);
|
|
|
|
BKE_ptcache_update_info(pid);
|
|
}
|
|
|
|
void BKE_ptcache_update_info(PTCacheID *pid)
|
|
{
|
|
PointCache *cache = pid->cache;
|
|
int totframes = 0;
|
|
char mem_info[64];
|
|
|
|
if(cache->flag & PTCACHE_EXTERNAL) {
|
|
int cfra = cache->startframe;
|
|
|
|
for(; cfra<=cache->endframe; cfra++) {
|
|
if(BKE_ptcache_id_exist(pid, cfra))
|
|
totframes++;
|
|
}
|
|
|
|
if(totframes && cache->totpoint)
|
|
sprintf(cache->info, "%i points found!", cache->totpoint);
|
|
else
|
|
sprintf(cache->info, "No valid data to read!");
|
|
return;
|
|
}
|
|
|
|
if(cache->flag & PTCACHE_DISK_CACHE) {
|
|
int cfra = cache->startframe;
|
|
|
|
for(; cfra<=cache->endframe; cfra++) {
|
|
if(BKE_ptcache_id_exist(pid, cfra))
|
|
totframes++;
|
|
}
|
|
|
|
sprintf(mem_info, "%i frames on disk", totframes);
|
|
}
|
|
else {
|
|
PTCacheMem *pm = cache->mem_cache.first;
|
|
float framesize = 0.0f, bytes = 0.0f;
|
|
int mb;
|
|
|
|
if(pm)
|
|
framesize = (float)ptcache_pid_old_elemsize(pid) * (float)pm->totpoint;
|
|
|
|
for(; pm; pm=pm->next)
|
|
totframes++;
|
|
|
|
bytes = totframes * framesize;
|
|
|
|
mb = (bytes > 1024.0f * 1024.0f);
|
|
|
|
sprintf(mem_info, "%i frames in memory (%.1f %s)",
|
|
totframes,
|
|
bytes / (mb ? 1024.0f * 1024.0f : 1024.0f),
|
|
mb ? "Mb" : "kb");
|
|
}
|
|
|
|
if(cache->flag & PTCACHE_OUTDATED) {
|
|
sprintf(cache->info, "%s, cache is outdated!", mem_info);
|
|
}
|
|
else if(cache->flag & PTCACHE_FRAMES_SKIPPED) {
|
|
sprintf(cache->info, "%s, not exact since frame %i.", mem_info, cache->last_exact);
|
|
}
|
|
else
|
|
sprintf(cache->info, "%s.", mem_info);
|
|
}
|