BKE_pointcache.h

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2006 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include "BLI_function_ref.hh"
 
#include "DNA_boid_types.h"       /* for #BoidData */
#include "DNA_pointcache_types.h" /* for #BPHYS_TOT_DATA */
 
#include <stdio.h> /* for #FILE */
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* Point cache clearing option, for BKE_ptcache_id_clear, before
 * and after are non-inclusive (they won't remove the cfra) */
#define PTCACHE_CLEAR_ALL 0
#define PTCACHE_CLEAR_FRAME 1
#define PTCACHE_CLEAR_BEFORE 2
#define PTCACHE_CLEAR_AFTER 3
 
/* Point cache reset options */
#define PTCACHE_RESET_DEPSGRAPH 0
#define PTCACHE_RESET_BAKED 1
#define PTCACHE_RESET_OUTDATED 2
// #define PTCACHE_RESET_FREE 3  /*UNUSED*/
 
/* Add the blend-file name after `blendcache_`. */
#define PTCACHE_EXT ".bphys"
#define PTCACHE_PATH "blendcache_"
 
/* File open options, for BKE_ptcache_file_open */
#define PTCACHE_FILE_READ 0
#define PTCACHE_FILE_WRITE 1
#define PTCACHE_FILE_UPDATE 2
 
/* PTCacheID types */
#define PTCACHE_TYPE_SOFTBODY 0
#define PTCACHE_TYPE_PARTICLES 1
#define PTCACHE_TYPE_CLOTH 2
#define PTCACHE_TYPE_SMOKE_DOMAIN 3
#define PTCACHE_TYPE_SMOKE_HIGHRES 4
#define PTCACHE_TYPE_DYNAMICPAINT 5
#define PTCACHE_TYPE_RIGIDBODY 6
 
/* high bits reserved for flags that need to be stored in file */
#define PTCACHE_TYPEFLAG_COMPRESS (1 << 16)
#define PTCACHE_TYPEFLAG_EXTRADATA (1 << 17)
 
#define PTCACHE_TYPEFLAG_TYPEMASK 0x0000FFFF
#define PTCACHE_TYPEFLAG_FLAGMASK 0xFFFF0000
 
/* PTCache read return code */
#define PTCACHE_READ_EXACT 1
#define PTCACHE_READ_INTERPOLATED 2
#define PTCACHE_READ_OLD 3
 
/* Structs */
struct BlendDataReader;
struct BlendWriter;
struct ClothModifierData;
struct DynamicPaintSurface;
struct FluidModifierData;
struct ListBase;
struct Main;
struct ModifierData;
struct Object;
struct ParticleKey;
struct ParticleSystem;
struct PointCache;
struct RigidBodyWorld;
struct Scene;
struct SoftBody;
struct ViewLayer;
 
/* temp structure for read/write */
typedef struct PTCacheData {
  unsigned int index;
  float loc[3];
  float vel[3];
  float rot[4];
  float ave[3];
  float size;
  float times[3];
  struct BoidData boids;
} PTCacheData;
 
typedef struct PTCacheFile {
  FILE *fp;
 
  int frame, old_format;
  unsigned int totpoint, type;
  unsigned int data_types, flag;
 
  struct PTCacheData data;
  void *cur[BPHYS_TOT_DATA];
} PTCacheFile;
 
#define PTCACHE_VEL_PER_SEC 1
 
enum {
  PTCACHE_FILE_PTCACHE = 0,
};
 
typedef struct PTCacheID {
  struct PTCacheID *next, *prev;
 
  struct Scene *scene;
  struct ID *owner_id;
  void *calldata;
  unsigned int type, file_type;
  unsigned int stack_index;
  unsigned int flag;
 
  unsigned int default_step;
  unsigned int max_step;
 
  unsigned int data_types, info_types;
 
  int (*write_point)(int index, void *calldata, void **data, int cfra);
  void (*read_point)(int index, void *calldata, void **data, float cfra, const float *old_data);
  void (*interpolate_point)(int index,
                            void *calldata,
                            void **data,
                            float cfra,
                            float cfra1,
                            float cfra2,
                            const float *old_data);
 
  int (*write_stream)(PTCacheFile *pf, void *calldata);
  int (*read_stream)(PTCacheFile *pf, void *calldata);
 
  void (*write_extra_data)(void *calldata, struct PTCacheMem *pm, int cfra);
  void (*read_extra_data)(void *calldata, struct PTCacheMem *pm, float cfra);
  void (*interpolate_extra_data)(
      void *calldata, struct PTCacheMem *pm, float cfra, float cfra1, float cfra2);
 
  int (*totpoint)(void *calldata, int cfra);
  void (*error)(const struct ID *owner_id, void *calldata, const char *message);
  int (*totwrite)(void *calldata, int cfra);
 
  int (*write_header)(PTCacheFile *pf);
  int (*read_header)(PTCacheFile *pf);
 
  struct PointCache *cache;
  struct PointCache **cache_ptr;
  struct ListBase *ptcaches;
} PTCacheID;
 
typedef struct PTCacheBaker {
  struct Main *bmain;
  struct Scene *scene;
  struct ViewLayer *view_layer;
  struct Depsgraph *depsgraph;
  bool bake;
  bool render;
  bool anim_init;
  int quick_step;
  struct PTCacheID pid;
 
  void (*update_progress)(void *data, float progress, int *cancel);
  void *bake_job;
} PTCacheBaker;
 
/* PTCacheEditKey->flag */
#define PEK_SELECT 1
#define PEK_TAG 2
#define PEK_HIDE 4
#define PEK_USE_WCO 8
 
typedef struct PTCacheEditKey {
  float *co;
  float *vel;
  float *rot;
  float *time;
 
  float world_co[3];
  float ftime;
  float length;
  short flag;
} PTCacheEditKey;
 
/* PTCacheEditPoint->flag */
#define PEP_TAG 1
#define PEP_EDIT_RECALC 2
#define PEP_TRANSFORM 4
#define PEP_HIDE 8
 
typedef struct PTCacheEditPoint {
  struct PTCacheEditKey *keys;
  int totkey;
  short flag;
} PTCacheEditPoint;
 
typedef struct PTCacheUndo {
  struct PTCacheEditPoint *points;
 
  /* particles stuff */
  struct ParticleData *particles;
  struct KDTree_3d *emitter_field;
  float *emitter_cosnos;
  int psys_flag;
 
  /* cache stuff */
  struct ListBase mem_cache;
 
  int totpoint;
 
  size_t undo_size;
} PTCacheUndo;
 
enum {
  /* Modifier stack got evaluated during particle edit mode, need to copy
   * new evaluated particles to the edit struct.
   */
  PT_CACHE_EDIT_UPDATE_PARTICLE_FROM_EVAL = (1 << 0),
};
 
typedef struct PTCacheEdit {
  int flags;
 
  PTCacheEditPoint *points;
 
  struct PTCacheID pid;
 
  /* particles stuff */
  struct ParticleSystem *psys;
  struct ParticleSystem *psys_eval;
  struct ParticleSystemModifierData *psmd;
  struct ParticleSystemModifierData *psmd_eval;
  struct KDTree_3d *emitter_field;
  float *emitter_cosnos;
  int *mirror_cache;
 
  struct ParticleCacheKey **pathcache; /* path cache (runtime) */
  ListBase pathcachebufs;
 
  int totpoint, totframes, totcached, edited;
} PTCacheEdit;
 
void BKE_ptcache_make_particle_key(struct ParticleKey *key, int index, void **data, float time);
 
/**************** Creating ID's ****************************/
 
void BKE_ptcache_id_from_softbody(PTCacheID *pid, struct Object *ob, struct SoftBody *sb);
void BKE_ptcache_id_from_particles(PTCacheID *pid, struct Object *ob, struct ParticleSystem *psys);
void BKE_ptcache_id_from_cloth(PTCacheID *pid, struct Object *ob, struct ClothModifierData *clmd);
void BKE_ptcache_id_from_smoke(PTCacheID *pid, struct Object *ob, struct FluidModifierData *fmd);
void BKE_ptcache_id_from_dynamicpaint(PTCacheID *pid,
                                      struct Object *ob,
                                      struct DynamicPaintSurface *surface);
void BKE_ptcache_id_from_rigidbody(PTCacheID *pid, struct Object *ob, struct RigidBodyWorld *rbw);
 
PTCacheID BKE_ptcache_id_find(struct Object *ob, struct Scene *scene, struct PointCache *cache);
void BKE_ptcache_ids_from_object(struct ListBase *lb,
                                 struct Object *ob,
                                 struct Scene *scene,
                                 int duplis);
 
using PointCacheIdFn = blender::FunctionRef<bool(PTCacheID &pid, ModifierData *md)>;
void BKE_ptcache_foreach_object_cache(struct Object &ob,
                                      struct Scene &scene,
                                      bool duplis,
                                      PointCacheIdFn fn);
 
/****************** Query functions ****************************/
 
bool BKE_ptcache_object_has(struct Scene *scene, struct Object *ob, int duplis);
 
/************ ID specific functions ************************/
 
void BKE_ptcache_id_clear(PTCacheID *pid, int mode, unsigned int cfra);
bool BKE_ptcache_id_exist(PTCacheID *pid, int cfra);
int BKE_ptcache_id_reset(struct Scene *scene, PTCacheID *pid, int mode);
void BKE_ptcache_id_time(PTCacheID *pid,
                         struct Scene *scene,
                         float cfra,
                         int *startframe,
                         int *endframe,
                         float *timescale);
int BKE_ptcache_object_reset(struct Scene *scene, struct Object *ob, int mode);
 
void BKE_ptcache_update_info(PTCacheID *pid);
 
/*********** General cache reading/writing ******************/
 
int BKE_ptcache_data_size(int data_type);
 
int BKE_ptcache_mem_index_find(struct PTCacheMem *pm, unsigned int index);
 
/* Memory cache read/write helpers. */
 
void BKE_ptcache_mem_pointers_init(struct PTCacheMem *pm, void *cur[BPHYS_TOT_DATA]);
void BKE_ptcache_mem_pointers_incr(void *cur[BPHYS_TOT_DATA]);
int BKE_ptcache_mem_pointers_seek(int point_index,
                                  struct PTCacheMem *pm,
                                  void *cur[BPHYS_TOT_DATA]);
 
int BKE_ptcache_read(PTCacheID *pid, float cfra, bool no_extrapolate_old);
 
int BKE_ptcache_write(PTCacheID *pid, unsigned int cfra);
 
/******************* Allocate & free ***************/
 
struct PointCache *BKE_ptcache_add(struct ListBase *ptcaches);
void BKE_ptcache_free_mem(struct ListBase *mem_cache);
void BKE_ptcache_free(struct PointCache *cache);
void BKE_ptcache_free_list(struct ListBase *ptcaches);
struct PointCache *BKE_ptcache_copy_list(struct ListBase *ptcaches_new,
                                         const struct ListBase *ptcaches_old,
                                         int flag);
 
/********************** Baking *********************/
 
void BKE_ptcache_quick_cache_all(struct Main *bmain,
                                 struct Scene *scene,
                                 struct ViewLayer *view_layer);
 
void BKE_ptcache_bake(struct PTCacheBaker *baker);
 
void BKE_ptcache_disk_to_mem(struct PTCacheID *pid);
void BKE_ptcache_mem_to_disk(struct PTCacheID *pid);
void BKE_ptcache_toggle_disk_cache(struct PTCacheID *pid);
void BKE_ptcache_disk_cache_rename(struct PTCacheID *pid,
                                   const char *name_src,
                                   const char *name_dst);
 
void BKE_ptcache_load_external(struct PTCacheID *pid);
void BKE_ptcache_validate(struct PointCache *cache, int framenr);
void BKE_ptcache_invalidate(struct PointCache *cache);
 
/********************** .blend File I/O *********************/
 
void BKE_ptcache_blend_write(struct BlendWriter *writer, struct ListBase *ptcaches);
void BKE_ptcache_blend_read_data(struct BlendDataReader *reader,
                                 struct ListBase *ptcaches,
                                 struct PointCache **ocache,
                                 int force_disk);
 
#ifdef __cplusplus
}
#endif