91803e130f
e.g. stands for "exempli gratia" in Latin which means "for example". The best way to make sure it makes sense when writing is to just expand it to "for example". In these cases where the text was "for e.g.", that leaves us with "for for example" which makes no sense. This commit fixes all 110 cases, mostly just just replacing the words with "for example", but also restructuring the text a bit more in a few cases, mostly by moving "e.g." to the beginning of a list in parentheses. Pull Request: https://projects.blender.org/blender/blender/pulls/139596
275 lines
9.1 KiB
C
275 lines
9.1 KiB
C
/* SPDX-FileCopyrightText: 2001-2002 NaN Holding BV. All rights reserved.
|
|
*
|
|
* SPDX-License-Identifier: GPL-2.0-or-later */
|
|
#pragma once
|
|
|
|
/** \file
|
|
* \ingroup bke
|
|
*/
|
|
|
|
struct Collection;
|
|
struct Depsgraph;
|
|
struct ListBase;
|
|
struct RNG;
|
|
struct Object;
|
|
struct ParticleData;
|
|
struct ParticleKey;
|
|
struct ParticleSimulationData;
|
|
struct Scene;
|
|
struct ViewLayer;
|
|
|
|
struct EffectorWeights *BKE_effector_add_weights(struct Collection *collection);
|
|
|
|
/* Input to effector code */
|
|
typedef struct EffectedPoint {
|
|
float *loc;
|
|
float *vel;
|
|
float *ave; /* angular velocity for particles with dynamic rotation */
|
|
float *rot; /* rotation quaternion for particles with dynamic rotation */
|
|
float vel_to_frame;
|
|
float vel_to_sec;
|
|
|
|
/* only for particles */
|
|
float size, charge;
|
|
|
|
unsigned int flag;
|
|
int index;
|
|
|
|
struct ParticleSystem *psys; /* particle system the point belongs to */
|
|
} EffectedPoint;
|
|
|
|
typedef struct GuideEffectorData {
|
|
float vec_to_point[3];
|
|
float strength;
|
|
} GuideEffectorData;
|
|
|
|
typedef struct EffectorData {
|
|
/* Effector point */
|
|
float loc[3];
|
|
float nor[3];
|
|
float vel[3];
|
|
|
|
float vec_to_point[3];
|
|
float distance, falloff;
|
|
|
|
/* only for effector particles */
|
|
float size, charge;
|
|
|
|
/* only for vortex effector with surface falloff */
|
|
float nor2[3], vec_to_point2[3];
|
|
|
|
int *index; /* point index */
|
|
} EffectorData;
|
|
|
|
/* used for calculating the effector force */
|
|
typedef struct EffectorCache {
|
|
struct EffectorCache *next, *prev;
|
|
|
|
struct Depsgraph *depsgraph;
|
|
struct Scene *scene;
|
|
struct Object *ob;
|
|
struct ParticleSystem *psys;
|
|
struct SurfaceModifierData *surmd;
|
|
|
|
struct PartDeflect *pd;
|
|
|
|
/** Random noise generator, e.g. for wind. */
|
|
struct RNG *rng;
|
|
|
|
/* precalculated for guides */
|
|
struct GuideEffectorData *guide_data;
|
|
float guide_loc[4], guide_dir[3], guide_radius;
|
|
|
|
float frame;
|
|
int flag;
|
|
} EffectorCache;
|
|
|
|
typedef struct EffectorRelation {
|
|
struct EffectorRelation *next, *prev;
|
|
|
|
struct Object *ob;
|
|
struct ParticleSystem *psys;
|
|
struct PartDeflect *pd;
|
|
} EffectorRelation;
|
|
|
|
struct PartDeflect *BKE_partdeflect_new(int type);
|
|
struct PartDeflect *BKE_partdeflect_copy(const struct PartDeflect *pd_src);
|
|
void BKE_partdeflect_free(struct PartDeflect *pd);
|
|
|
|
/**
|
|
* Create list of effector relations in the collection or entire scene.
|
|
* This is used by the depsgraph to build relations, as well as faster
|
|
* lookup of effectors during evaluation.
|
|
*/
|
|
struct ListBase *BKE_effector_relations_create(struct Depsgraph *depsgraph,
|
|
const struct Scene *scene,
|
|
struct ViewLayer *view_layer,
|
|
struct Collection *collection);
|
|
void BKE_effector_relations_free(struct ListBase *lb);
|
|
|
|
/**
|
|
* Create effective list of effectors from relations built beforehand.
|
|
*/
|
|
struct ListBase *BKE_effectors_create(struct Depsgraph *depsgraph,
|
|
struct Object *ob_src,
|
|
struct ParticleSystem *psys_src,
|
|
struct EffectorWeights *weights,
|
|
bool use_rotation);
|
|
/**
|
|
* Generic force/speed system, now used for particles, soft-bodies & dynamic-paint.
|
|
*/
|
|
void BKE_effectors_apply(struct ListBase *effectors,
|
|
struct ListBase *colliders,
|
|
struct EffectorWeights *weights,
|
|
struct EffectedPoint *point,
|
|
float *force,
|
|
float *wind_force,
|
|
float *impulse);
|
|
void BKE_effectors_free(struct ListBase *lb);
|
|
|
|
void pd_point_from_particle(struct ParticleSimulationData *sim,
|
|
struct ParticleData *pa,
|
|
struct ParticleKey *state,
|
|
struct EffectedPoint *point);
|
|
void pd_point_from_loc(
|
|
struct Scene *scene, float *loc, float *vel, int index, struct EffectedPoint *point);
|
|
void pd_point_from_soft(
|
|
struct Scene *scene, float *loc, float *vel, int index, struct EffectedPoint *point);
|
|
|
|
/* needed for boids */
|
|
float effector_falloff(struct EffectorCache *eff,
|
|
struct EffectorData *efd,
|
|
struct EffectedPoint *point,
|
|
struct EffectorWeights *weights);
|
|
bool closest_point_on_surface(struct SurfaceModifierData *surmd,
|
|
const float co[3],
|
|
float surface_co[3],
|
|
float surface_nor[3],
|
|
float surface_vel[3]);
|
|
bool get_effector_data(struct EffectorCache *eff,
|
|
struct EffectorData *efd,
|
|
struct EffectedPoint *point,
|
|
int real_velocity);
|
|
|
|
/* Required for `particle_system.cc`. */
|
|
#if 0
|
|
void do_physical_effector(struct EffectorData *eff,
|
|
struct EffectorPoint *point,
|
|
float *total_force);
|
|
float effector_falloff(struct EffectorData *eff,
|
|
struct EffectorPoint *point,
|
|
struct EffectorWeights *weights);
|
|
#endif
|
|
|
|
/* EffectedPoint->flag */
|
|
#define PE_WIND_AS_SPEED 1
|
|
#define PE_USE_NORMAL_DATA 4
|
|
|
|
/* EffectorData->flag */
|
|
#define PE_VELOCITY_TO_IMPULSE 1
|
|
|
|
/* ======== Simulation Debugging ======== */
|
|
|
|
unsigned int BKE_sim_debug_data_hash(int i);
|
|
unsigned int BKE_sim_debug_data_hash_combine(unsigned int kx, unsigned int ky);
|
|
|
|
/* _VA_SIM_DEBUG_HASH#(i, ...): combined hash value of multiple integers */
|
|
/* Internal helpers. */
|
|
#define _VA_SIM_DEBUG_HASH1(a) (BKE_sim_debug_data_hash(a))
|
|
#define _VA_SIM_DEBUG_HASH2(a, b) \
|
|
(BKE_sim_debug_data_hash_combine(BKE_sim_debug_data_hash(a), _VA_SIM_DEBUG_HASH1(b)))
|
|
#define _VA_SIM_DEBUG_HASH3(a, b, c) \
|
|
(BKE_sim_debug_data_hash_combine(BKE_sim_debug_data_hash(a), _VA_SIM_DEBUG_HASH2(b, c)))
|
|
#define _VA_SIM_DEBUG_HASH4(a, b, c, d) \
|
|
(BKE_sim_debug_data_hash_combine(BKE_sim_debug_data_hash(a), _VA_SIM_DEBUG_HASH3(b, c, d)))
|
|
#define _VA_SIM_DEBUG_HASH5(a, b, c, d, e) \
|
|
(BKE_sim_debug_data_hash_combine(BKE_sim_debug_data_hash(a), _VA_SIM_DEBUG_HASH4(b, c, d, e)))
|
|
#define _VA_SIM_DEBUG_HASH6(a, b, c, d, e, f) \
|
|
(BKE_sim_debug_data_hash_combine(BKE_sim_debug_data_hash(a), _VA_SIM_DEBUG_HASH5(b, c, d, e, f)))
|
|
#define _VA_SIM_DEBUG_HASH7(a, b, c, d, e, f, g) \
|
|
(BKE_sim_debug_data_hash_combine(BKE_sim_debug_data_hash(a), \
|
|
_VA_SIM_DEBUG_HASH6(b, c, d, e, f, g)))
|
|
#define _VA_SIM_DEBUG_HASH8(a, b, c, d, e, f, g, h) \
|
|
(BKE_sim_debug_data_hash_combine(BKE_sim_debug_data_hash(a), \
|
|
_VA_SIM_DEBUG_HASH7(b, c, d, e, f, g, h)))
|
|
|
|
#define SIM_DEBUG_HASH(...) VA_NARGS_CALL_OVERLOAD(_VA_SIM_DEBUG_HASH, __VA_ARGS__)
|
|
|
|
typedef struct SimDebugElement {
|
|
unsigned int category_hash;
|
|
unsigned int hash;
|
|
|
|
int type;
|
|
float color[3];
|
|
|
|
float v1[3], v2[3];
|
|
char str[64];
|
|
} SimDebugElement;
|
|
|
|
typedef enum eSimDebugElement_Type {
|
|
SIM_DEBUG_ELEM_DOT,
|
|
SIM_DEBUG_ELEM_CIRCLE,
|
|
SIM_DEBUG_ELEM_LINE,
|
|
SIM_DEBUG_ELEM_VECTOR,
|
|
SIM_DEBUG_ELEM_STRING,
|
|
} eSimDebugElement_Type;
|
|
|
|
typedef struct SimDebugData {
|
|
struct GHash *gh;
|
|
} SimDebugData;
|
|
|
|
extern SimDebugData *_sim_debug_data;
|
|
|
|
void BKE_sim_debug_data_set_enabled(bool enable);
|
|
bool BKE_sim_debug_data_get_enabled(void);
|
|
void BKE_sim_debug_data_free(void);
|
|
|
|
void BKE_sim_debug_data_add_element(int type,
|
|
const float v1[3],
|
|
const float v2[3],
|
|
const char *str,
|
|
float r,
|
|
float g,
|
|
float b,
|
|
const char *category,
|
|
unsigned int hash);
|
|
void BKE_sim_debug_data_remove_element(unsigned int hash);
|
|
|
|
#define BKE_sim_debug_data_add_dot(p, r, g, b, category, ...) \
|
|
{ \
|
|
const float v2[3] = {0.0f, 0.0f, 0.0f}; \
|
|
BKE_sim_debug_data_add_element( \
|
|
SIM_DEBUG_ELEM_DOT, p, v2, NULL, r, g, b, category, SIM_DEBUG_HASH(__VA_ARGS__)); \
|
|
}
|
|
|
|
#define BKE_sim_debug_data_add_circle(p, radius, r, g, b, category, ...) \
|
|
{ \
|
|
const float v2[3] = {radius, 0.0f, 0.0f}; \
|
|
BKE_sim_debug_data_add_element( \
|
|
SIM_DEBUG_ELEM_CIRCLE, p, v2, NULL, r, g, b, category, SIM_DEBUG_HASH(__VA_ARGS__)); \
|
|
}
|
|
|
|
#define BKE_sim_debug_data_add_line(p1, p2, r, g, b, category, ...) \
|
|
{ \
|
|
BKE_sim_debug_data_add_element( \
|
|
SIM_DEBUG_ELEM_LINE, p1, p2, NULL, r, g, b, category, SIM_DEBUG_HASH(__VA_ARGS__)); \
|
|
}
|
|
|
|
#define BKE_sim_debug_data_add_vector(p, d, r, g, b, category, ...) \
|
|
{ \
|
|
BKE_sim_debug_data_add_element( \
|
|
SIM_DEBUG_ELEM_VECTOR, p, d, NULL, r, g, b, category, SIM_DEBUG_HASH(__VA_ARGS__)); \
|
|
}
|
|
|
|
#define BKE_sim_debug_data_add_string(p, str, r, g, b, category, ...) \
|
|
{ \
|
|
BKE_sim_debug_data_add_element( \
|
|
SIM_DEBUG_ELEM_STRING, p, NULL, str, r, g, b, category, SIM_DEBUG_HASH(__VA_ARGS__)); \
|
|
}
|
|
|
|
#define BKE_sim_debug_data_remove(...) \
|
|
BKE_sim_debug_data_remove_element(SIM_DEBUG_HASH(__VA_ARGS__))
|
|
|
|
void BKE_sim_debug_data_clear(void);
|
|
void BKE_sim_debug_data_clear_category(const char *category);
|