forked from bartvdbraak/blender
Spelling Cleanup
This commit is contained in:
parent
6a36b6249b
commit
ea13ec1699
16
GNUmakefile
16
GNUmakefile
@ -166,10 +166,11 @@ help:
|
||||
@echo " * test_deprecated - checks for deprecation tags in our code which may need to be removed"
|
||||
@echo ""
|
||||
@echo "Static Source Code Checking (not assosiated with building blender)"
|
||||
@echo " * check_cppcheck - run blender source through cppcheck (C & C++)"
|
||||
@echo " * check_splint - run blenders source through splint (C only)"
|
||||
@echo " * check_sparse - run blenders source through sparse (C only)"
|
||||
@echo " * check_spelling - check for spelling errors (Python only for now)"
|
||||
@echo " * check_cppcheck - run blender source through cppcheck (C & C++)"
|
||||
@echo " * check_splint - run blenders source through splint (C only)"
|
||||
@echo " * check_sparse - run blenders source through sparse (C only)"
|
||||
@echo " * check_spelling_c - check for spelling errors (C/C++ only)"
|
||||
@echo " * check_spelling_py - check for spelling errors (Python only)"
|
||||
@echo ""
|
||||
@echo "Documentation Targets (not assosiated with building blender)"
|
||||
@echo " * doc_py - generate sphinx python api docs"
|
||||
@ -243,8 +244,11 @@ check_sparse:
|
||||
$(CMAKE_CONFIG)
|
||||
cd $(BUILD_DIR) ; python3 $(BLENDER_DIR)/build_files/cmake/cmake_static_check_sparse.py
|
||||
|
||||
check_spelling:
|
||||
cd $(BUILD_DIR) ; PYTHONIOENCODING=utf_8 python3 $(BLENDER_DIR)/source/tools/spell_check_source.py `find $(BLENDER_DIR)/release/scripts -name "*.py" | sort`
|
||||
check_spelling_py:
|
||||
cd $(BUILD_DIR) ; PYTHONIOENCODING=utf_8 python3 $(BLENDER_DIR)/source/tools/spell_check_source.py $(BLENDER_DIR)/release/scripts
|
||||
|
||||
check_spelling_c:
|
||||
cd $(BUILD_DIR) ; PYTHONIOENCODING=utf_8 python3 $(BLENDER_DIR)/source/tools/spell_check_source.py $(BLENDER_DIR)/source
|
||||
|
||||
|
||||
# -----------------------------------------------------------------------------
|
||||
|
@ -125,7 +125,7 @@ class SelectCamera(Operator):
|
||||
|
||||
|
||||
class SelectHierarchy(Operator):
|
||||
'''Select object relative to the active object's position''' \
|
||||
'''Select object relative to the active object's position ''' \
|
||||
'''in the hierarchy'''
|
||||
bl_idname = "object.select_hierarchy"
|
||||
bl_label = "Select Hierarchy"
|
||||
|
@ -75,7 +75,7 @@ typedef struct BVHTreeFromMesh
|
||||
*
|
||||
* The tree is build in mesh space coordinates, this means special care must be made on queries
|
||||
* so that the coordinates and rays are first translated on the mesh local coordinates.
|
||||
* Reason for this is that later bvh_from_mesh_* might use a cache system and so it becames possible to reuse
|
||||
* Reason for this is that later bvh_from_mesh_* might use a cache system and so it becomes possible to reuse
|
||||
* a BVHTree.
|
||||
*
|
||||
* free_bvhtree_from_mesh should be called when the tree is no longer needed.
|
||||
@ -88,7 +88,7 @@ BVHTree* bvhtree_from_mesh_verts(struct BVHTreeFromMesh *data, struct DerivedMes
|
||||
*
|
||||
* The tree is build in mesh space coordinates, this means special care must be made on queries
|
||||
* so that the coordinates and rays are first translated on the mesh local coordinates.
|
||||
* Reason for this is that later bvh_from_mesh_* might use a cache system and so it becames possible to reuse
|
||||
* Reason for this is that later bvh_from_mesh_* might use a cache system and so it becomes possible to reuse
|
||||
* a BVHTree.
|
||||
*
|
||||
* The returned value is the same as in data->tree, its only returned to make it easier to test
|
||||
@ -124,7 +124,7 @@ typedef struct LinkNode* BVHCache;
|
||||
|
||||
|
||||
/*
|
||||
* Queries a bvhcache for the chache bvhtree of the request type
|
||||
* Queries a bvhcache for the cache bvhtree of the request type
|
||||
*/
|
||||
BVHTree *bvhcache_find(BVHCache *cache, int type);
|
||||
|
||||
|
@ -135,7 +135,7 @@ typedef struct FModifierTypeInfo {
|
||||
void (*evaluate_modifier)(struct FCurve *fcu, struct FModifier *fcm, float *cvalue, float evaltime);
|
||||
} FModifierTypeInfo;
|
||||
|
||||
/* Values which describe the behaviour of a FModifier Type */
|
||||
/* Values which describe the behavior of a FModifier Type */
|
||||
typedef enum eFMI_Action_Types {
|
||||
/* modifier only modifies values outside of data range */
|
||||
FMI_TYPE_EXTRAPOLATION = 0,
|
||||
|
@ -170,7 +170,7 @@ void give_ibuf_prefetch_request(SeqRenderData context, float cfra, int chan_show
|
||||
int seqbase_recursive_apply(struct ListBase *seqbase, int (*apply_func)(struct Sequence *seq, void *), void *arg);
|
||||
int seq_recursive_apply(struct Sequence *seq, int (*apply_func)(struct Sequence *, void *), void *arg);
|
||||
|
||||
/* maintainance functions, mostly for RNA */
|
||||
/* maintenance functions, mostly for RNA */
|
||||
// extern
|
||||
void seq_free_sequence(struct Scene *scene, struct Sequence *seq);
|
||||
void seq_free_sequence_recurse(struct Scene *scene, struct Sequence *seq);
|
||||
|
@ -1359,7 +1359,7 @@ static void mesh_calc_modifiers(Scene *scene, Object *ob, float (*inputVertexCos
|
||||
}
|
||||
}
|
||||
} else {
|
||||
/* default behaviour for meshes */
|
||||
/* default behavior for meshes */
|
||||
if(inputVertexCos)
|
||||
deformedVerts = inputVertexCos;
|
||||
else
|
||||
|
@ -81,7 +81,7 @@ static void object_duplilist_recursive(ID *id, Scene *scene, Object *ob, ListBas
|
||||
/* ******************************************************************** */
|
||||
/* Animation Visualisation */
|
||||
|
||||
/* Initialise the default settings for animation visualisation */
|
||||
/* Initialize the default settings for animation visualisation */
|
||||
void animviz_settings_init(bAnimVizSettings *avs)
|
||||
{
|
||||
/* sanity check */
|
||||
@ -234,7 +234,7 @@ typedef struct MPathTarget {
|
||||
/* get list of motion paths to be baked for the given object
|
||||
* - assumes the given list is ready to be used
|
||||
*/
|
||||
// TODO: it would be nice in future to be able to update objects dependant on these bones too?
|
||||
// TODO: it would be nice in future to be able to update objects dependent on these bones too?
|
||||
void animviz_get_object_motionpaths(Object *ob, ListBase *targets)
|
||||
{
|
||||
MPathTarget *mpt;
|
||||
|
@ -2144,7 +2144,7 @@ static void animsys_evaluate_overrides (PointerRNA *ptr, AnimData *adt)
|
||||
|
||||
/* Overview of how this system works:
|
||||
* 1) Depsgraph sorts data as necessary, so that data is in an order that means
|
||||
* that all dependences are resolved before dependants.
|
||||
* that all dependencies are resolved before dependants.
|
||||
* 2) All normal animation is evaluated, so that drivers have some basis values to
|
||||
* work with
|
||||
* a. NLA stacks are done first, as the Active Actions act as 'tweaking' tracks
|
||||
@ -2153,14 +2153,14 @@ static void animsys_evaluate_overrides (PointerRNA *ptr, AnimData *adt)
|
||||
*
|
||||
* --------------< often in a separate phase... >------------------
|
||||
*
|
||||
* 3) Drivers/expressions are evaluated on top of this, in an order where dependences are
|
||||
* 3) Drivers/expressions are evaluated on top of this, in an order where dependencies are
|
||||
* resolved nicely.
|
||||
* Note: it may be necessary to have some tools to handle the cases where some higher-level
|
||||
* drivers are added and cause some problematic dependencies that didn't exist in the local levels...
|
||||
*
|
||||
* --------------< always executed >------------------
|
||||
*
|
||||
* Maintainance of editability of settings (XXX):
|
||||
* Maintenance of editability of settings (XXX):
|
||||
* In order to ensure that settings that are animated can still be manipulated in the UI without requiring
|
||||
* that keyframes are added to prevent these values from being overwritten, we use 'overrides'.
|
||||
*
|
||||
|
@ -2100,7 +2100,7 @@ DerivedMesh *CDDM_copy_from_tessface(DerivedMesh *source)
|
||||
}
|
||||
|
||||
/* note, the CD_ORIGINDEX layers are all 0, so if there is a direct
|
||||
* relationship betwen mesh data this needs to be set by the caller. */
|
||||
* relationship between mesh data this needs to be set by the caller. */
|
||||
DerivedMesh *CDDM_from_template(DerivedMesh *source,
|
||||
int numVerts, int numEdges, int numTessFaces,
|
||||
int numLoops, int numPolys)
|
||||
|
@ -1380,7 +1380,7 @@ static void machine_epsilon_offset(Cloth *cloth)
|
||||
|
||||
cv = cloth->verts;
|
||||
for (i=0; i<cloth->numverts; i++, cv++) {
|
||||
/*aggrevatingly enough, it's necassary to offset the coordinates
|
||||
/*aggrevatingly enough, it's necessary to offset the coordinates
|
||||
by a multiple of the 32-bit floating point epsilon when switching
|
||||
into doubles*/
|
||||
#define RNDSIGN (float)(-1*(BLI_rand()%2==0)|1)
|
||||
|
@ -671,7 +671,7 @@ static void default_get_tarmat (bConstraint *con, bConstraintOb *UNUSED(cob), bC
|
||||
}
|
||||
|
||||
/* This following macro should be used for all standard single-target *_get_tars functions
|
||||
* to save typing and reduce maintainance woes.
|
||||
* to save typing and reduce maintenance woes.
|
||||
* (Hopefully all compilers will be happy with the lines with just a space on them. Those are
|
||||
* really just to help this code easier to read)
|
||||
*/
|
||||
@ -705,7 +705,7 @@ static void default_get_tarmat (bConstraint *con, bConstraintOb *UNUSED(cob), bC
|
||||
}
|
||||
|
||||
/* This following macro should be used for all standard single-target *_get_tars functions
|
||||
* to save typing and reduce maintainance woes. It does not do the subtarget related operations
|
||||
* to save typing and reduce maintenance woes. It does not do the subtarget related operations
|
||||
* (Hopefully all compilers will be happy with the lines with just a space on them. Those are
|
||||
* really just to help this code easier to read)
|
||||
*/
|
||||
@ -724,7 +724,7 @@ static void default_get_tarmat (bConstraint *con, bConstraintOb *UNUSED(cob), bC
|
||||
}
|
||||
|
||||
/* This following macro should be used for all standard single-target *_flush_tars functions
|
||||
* to save typing and reduce maintainance woes.
|
||||
* to save typing and reduce maintenance woes.
|
||||
* Note: the pointer to ct will be changed to point to the next in the list (as it gets removed)
|
||||
* (Hopefully all compilers will be happy with the lines with just a space on them. Those are
|
||||
* really just to help this code easier to read)
|
||||
@ -745,7 +745,7 @@ static void default_get_tarmat (bConstraint *con, bConstraintOb *UNUSED(cob), bC
|
||||
}
|
||||
|
||||
/* This following macro should be used for all standard single-target *_flush_tars functions
|
||||
* to save typing and reduce maintainance woes. It does not do the subtarget related operations.
|
||||
* to save typing and reduce maintenance woes. It does not do the subtarget related operations.
|
||||
* Note: the pointer to ct will be changed to point to the next in the list (as it gets removed)
|
||||
* (Hopefully all compilers will be happy with the lines with just a space on them. Those are
|
||||
* really just to help this code easier to read)
|
||||
@ -2221,7 +2221,7 @@ static void actcon_get_tarmat (bConstraint *con, bConstraintOb *cob, bConstraint
|
||||
object_to_mat4(&workob, ct->matrix);
|
||||
}
|
||||
else {
|
||||
/* behaviour undefined... */
|
||||
/* behavior undefined... */
|
||||
puts("Error: unknown owner type for Action Constraint");
|
||||
}
|
||||
}
|
||||
@ -3920,7 +3920,7 @@ static bConstraintTypeInfo CTI_PIVOT = {
|
||||
NULL, /* relink data */
|
||||
pivotcon_id_looper, /* id looper */
|
||||
NULL, /* copy data */
|
||||
NULL, /* new data */ // XXX: might be needed to get 'normal' pivot behaviour...
|
||||
NULL, /* new data */ // XXX: might be needed to get 'normal' pivot behavior...
|
||||
pivotcon_get_tars, /* get constraint targets */
|
||||
pivotcon_flush_tars, /* flush constraint targets */
|
||||
default_get_tarmat, /* get target matrix */
|
||||
|
@ -104,7 +104,7 @@ typedef struct LayerTypeInfo {
|
||||
default is assumed to be all zeros */
|
||||
void (*set_default)(void *data, int count);
|
||||
|
||||
/* functions necassary for geometry collapse*/
|
||||
/* functions necessary for geometry collapse*/
|
||||
int (*equal)(void *data1, void *data2);
|
||||
void (*multiply)(void *data, float fac);
|
||||
void (*initminmax)(void *min, void *max);
|
||||
@ -1664,7 +1664,7 @@ void *CustomData_duplicate_referenced_layer(struct CustomData *data, const int t
|
||||
layer = &data->layers[layer_index];
|
||||
|
||||
if (layer->flag & CD_FLAG_NOFREE) {
|
||||
/* MEM_dupallocN won’t work in case of complex layers, like e.g.
|
||||
/* MEM_dupallocN won't work in case of complex layers, like e.g.
|
||||
* CD_MDEFORMVERT, which has pointers to allocated data...
|
||||
* So in case a custom copy function is defined, use it!
|
||||
*/
|
||||
@ -1697,7 +1697,7 @@ void *CustomData_duplicate_referenced_layer_named(struct CustomData *data,
|
||||
layer = &data->layers[layer_index];
|
||||
|
||||
if (layer->flag & CD_FLAG_NOFREE) {
|
||||
/* MEM_dupallocN won’t work in case of complex layers, like e.g.
|
||||
/* MEM_dupallocN won't work in case of complex layers, like e.g.
|
||||
* CD_MDEFORMVERT, which has pointers to allocated data...
|
||||
* So in case a custom copy function is defined, use it!
|
||||
*/
|
||||
|
@ -603,7 +603,7 @@ MDeformWeight *defvert_verify_index(MDeformVert *dvert, const int defgroup)
|
||||
/* TODO. merge with code above! */
|
||||
|
||||
/* Adds the given vertex to the specified vertex group, with given weight.
|
||||
* warning, this does NOT check for existign, assume caller already knows its not there */
|
||||
* warning, this does NOT check for existing, assume caller already knows its not there */
|
||||
void defvert_add_index_notest(MDeformVert *dvert, int defgroup, const float weight)
|
||||
{
|
||||
MDeformWeight *dw_new;
|
||||
|
@ -1116,7 +1116,7 @@ void graph_bfs(void)
|
||||
pos[i] = 0;
|
||||
|
||||
/* Init
|
||||
* dagnode.first is alway the root (scene)
|
||||
* dagnode.first is always the root (scene)
|
||||
*/
|
||||
node = MainDag->DagNode.first;
|
||||
while(node) {
|
||||
@ -1185,7 +1185,7 @@ int pre_and_post_source_BFS(DagForest *dag, short mask, DagNode *source, graph_a
|
||||
/* fprintf(stderr,"starting BFS \n ------------\n"); */
|
||||
|
||||
/* Init
|
||||
* dagnode.first is alway the root (scene)
|
||||
* dagnode.first is always the root (scene)
|
||||
*/
|
||||
node = dag->DagNode.first;
|
||||
nqueue = queue_create(DAGQUEUEALLOC);
|
||||
@ -1252,7 +1252,7 @@ DagNodeQueue * graph_dfs(void)
|
||||
pos[i] = 0;
|
||||
|
||||
/* Init
|
||||
* dagnode.first is alway the root (scene)
|
||||
* dagnode.first is always the root (scene)
|
||||
*/
|
||||
node = MainDag->DagNode.first;
|
||||
while(node) {
|
||||
@ -1376,7 +1376,7 @@ int pre_and_post_source_DFS(DagForest *dag, short mask, DagNode *source, graph_a
|
||||
nqueue = queue_create(DAGQUEUEALLOC);
|
||||
|
||||
/* Init
|
||||
* dagnode.first is alway the root (scene)
|
||||
* dagnode.first is always the root (scene)
|
||||
*/
|
||||
node = dag->DagNode.first;
|
||||
while(node) {
|
||||
|
@ -84,7 +84,7 @@ static float gaussianFactors[5] = { 0.996849f,
|
||||
0.524141f};
|
||||
static float gaussianTotal = 3.309425f;
|
||||
|
||||
/* UV Image neighbouring pixel table x and y list */
|
||||
/* UV Image neighboring pixel table x and y list */
|
||||
static int neighX[8] = {1,1,0,-1,-1,-1, 0, 1};
|
||||
static int neighY[8] = {0,1,1, 1, 0,-1,-1,-1};
|
||||
|
||||
@ -139,7 +139,7 @@ typedef struct Vec3f {
|
||||
} Vec3f;
|
||||
|
||||
typedef struct BakeAdjPoint {
|
||||
float dir[3]; /* vector pointing towards this neighbour */
|
||||
float dir[3]; /* vector pointing towards this neighbor */
|
||||
float dist; /* distance to */
|
||||
} BakeAdjPoint;
|
||||
|
||||
@ -160,7 +160,7 @@ typedef struct PaintBakeData {
|
||||
Bounds3D mesh_bounds;
|
||||
|
||||
/* adjacency info */
|
||||
BakeAdjPoint *bNeighs; /* current global neighbour distances and directions, if required */
|
||||
BakeAdjPoint *bNeighs; /* current global neighbor distances and directions, if required */
|
||||
double average_dist;
|
||||
/* space partitioning */
|
||||
VolumeGrid *grid; /* space partitioning grid to optimize brush checks */
|
||||
@ -183,7 +183,7 @@ typedef struct PaintUVPoint {
|
||||
unsigned int v1, v2, v3; /* vertex indexes */
|
||||
|
||||
unsigned int neighbour_pixel; /* If this pixel isn't uv mapped to any face,
|
||||
but it's neighbouring pixel is */
|
||||
but it's neighboring pixel is */
|
||||
short quad;
|
||||
} PaintUVPoint;
|
||||
|
||||
@ -196,7 +196,7 @@ typedef struct ImgSeqFormatData {
|
||||
#define ADJ_ON_MESH_EDGE (1<<0)
|
||||
|
||||
typedef struct PaintAdjData {
|
||||
int *n_target; /* array of neighbouring point indexes,
|
||||
int *n_target; /* array of neighboring point indexes,
|
||||
for single sample use (n_index+neigh_num) */
|
||||
int *n_index; /* index to start reading n_target for each point */
|
||||
int *n_num; /* num of neighs for each point */
|
||||
@ -1308,7 +1308,7 @@ static void dynamicPaint_initAdjacencyData(DynamicPaintSurface *surface, int for
|
||||
n_pos += ad->n_num[i];
|
||||
}
|
||||
|
||||
/* and now add neighbour data using that info */
|
||||
/* and now add neighbor data using that info */
|
||||
for (i=0; i<numOfEdges; i++) {
|
||||
/* first vertex */
|
||||
int index = edge[i].v1;
|
||||
@ -1889,7 +1889,7 @@ struct DerivedMesh *dynamicPaint_Modifier_do(DynamicPaintModifierData *pmd, Scen
|
||||
/***************************** Image Sequence / UV Image Surface Calls ******************************/
|
||||
|
||||
/*
|
||||
* Tries to find the neighbouring pixel in given (uv space) direction.
|
||||
* Tries to find the neighboring pixel in given (uv space) direction.
|
||||
* Result is used by effect system to move paint on the surface.
|
||||
*
|
||||
* px,py : origin pixel x and y
|
||||
@ -1898,7 +1898,7 @@ struct DerivedMesh *dynamicPaint_Modifier_do(DynamicPaintModifierData *pmd, Scen
|
||||
static int dynamicPaint_findNeighbourPixel(PaintUVPoint *tempPoints, DerivedMesh *dm,
|
||||
const char *uvname, int w, int h, int px, int py, int n_index)
|
||||
{
|
||||
/* Note: Current method only uses polygon edges to detect neighbouring pixels.
|
||||
/* Note: Current method only uses polygon edges to detect neighboring pixels.
|
||||
* -> It doesn't always lead to the optimum pixel but is accurate enough
|
||||
* and faster/simplier than including possible face tip point links)
|
||||
*/
|
||||
@ -1914,11 +1914,11 @@ static int dynamicPaint_findNeighbourPixel(PaintUVPoint *tempPoints, DerivedMesh
|
||||
if (x<0 || x>=w) return OUT_OF_TEXTURE;
|
||||
if (y<0 || y>=h) return OUT_OF_TEXTURE;
|
||||
|
||||
tPoint = &tempPoints[x+w*y]; /* UV neighbour */
|
||||
tPoint = &tempPoints[x+w*y]; /* UV neighbor */
|
||||
cPoint = &tempPoints[px+w*py]; /* Origin point */
|
||||
|
||||
/*
|
||||
* Check if shifted point is on same face -> it's a correct neighbour
|
||||
* Check if shifted point is on same face -> it's a correct neighbor
|
||||
* (and if it isn't marked as an "edge pixel")
|
||||
*/
|
||||
if ((tPoint->face_index == cPoint->face_index) && (tPoint->neighbour_pixel == -1))
|
||||
@ -1937,11 +1937,11 @@ static int dynamicPaint_findNeighbourPixel(PaintUVPoint *tempPoints, DerivedMesh
|
||||
}
|
||||
|
||||
/*
|
||||
* If we get here, the actual neighbouring pixel
|
||||
* If we get here, the actual neighboring pixel
|
||||
* is located on a non-linked uv face, and we have to find
|
||||
* it's "real" position.
|
||||
*
|
||||
* Simple neighbouring face finding algorithm:
|
||||
* Simple neighboring face finding algorithm:
|
||||
* - find closest uv edge to shifted pixel and get
|
||||
* the another face that shares that edge
|
||||
* - find corresponding position of that new face edge
|
||||
@ -2075,7 +2075,7 @@ static int dynamicPaint_findNeighbourPixel(PaintUVPoint *tempPoints, DerivedMesh
|
||||
if (tempPoints[final_index].face_index != target_face) return NOT_FOUND;
|
||||
|
||||
/*
|
||||
* If final point is an "edge pixel", use it's "real" neighbour instead
|
||||
* If final point is an "edge pixel", use it's "real" neighbor instead
|
||||
*/
|
||||
if (tempPoints[final_index].neighbour_pixel != -1) final_index = cPoint->neighbour_pixel;
|
||||
|
||||
@ -2322,7 +2322,7 @@ int dynamicPaint_createUVSurface(DynamicPaintSurface *surface)
|
||||
|
||||
/*
|
||||
* Now loop through every pixel that was left without index
|
||||
* and find if they have neighbouring pixels that have an index.
|
||||
* and find if they have neighboring pixels that have an index.
|
||||
* If so use that polygon as pixel surface.
|
||||
* (To avoid seams on uv island edges)
|
||||
*/
|
||||
@ -2350,14 +2350,14 @@ int dynamicPaint_createUVSurface(DynamicPaintSurface *surface)
|
||||
point[0] = ((float)tx + 0.5f) / w;
|
||||
point[1] = ((float)ty + 0.5f) / h;
|
||||
|
||||
/* search through defined area for neighbour */
|
||||
/* search through defined area for neighbor */
|
||||
for (u=u_min; u<=u_max; u++)
|
||||
for (v=v_min; v<=v_max; v++) {
|
||||
/* if not this pixel itself */
|
||||
if (u!=0 || v!=0) {
|
||||
ind = (tx+u)+w*(ty+v);
|
||||
|
||||
/* if neighbour has index */
|
||||
/* if neighbor has index */
|
||||
if (tempPoints[ind].face_index != -1) {
|
||||
|
||||
float uv1co[2], uv2co[2], uv3co[2], uv[2];
|
||||
@ -2402,7 +2402,7 @@ int dynamicPaint_createUVSurface(DynamicPaintSurface *surface)
|
||||
}
|
||||
|
||||
/*
|
||||
* When base loop is over convert found neighbour indexes to real ones
|
||||
* When base loop is over convert found neighbor indexes to real ones
|
||||
* Also count the final number of active surface points
|
||||
*/
|
||||
for (ty = 0; ty < h; ty++)
|
||||
@ -2450,7 +2450,7 @@ int dynamicPaint_createUVSurface(DynamicPaintSurface *surface)
|
||||
|
||||
for (i=0; i<8; i++) {
|
||||
|
||||
/* Try to find a neighbouring pixel in defined direction
|
||||
/* Try to find a neighboring pixel in defined direction
|
||||
* If not found, -1 is returned */
|
||||
int n_target = dynamicPaint_findNeighbourPixel(tempPoints, dm, uvname, w, h, tx, ty, i);
|
||||
|
||||
@ -3948,7 +3948,7 @@ void surface_determineForceTargetPoints(PaintSurfaceData *sData, int index, floa
|
||||
|
||||
if (n_index == closest_id[0]) continue;
|
||||
|
||||
/* only accept neighbour at "other side" of the first one in relation to force dir
|
||||
/* only accept neighbor at "other side" of the first one in relation to force dir
|
||||
* so make sure angle between this and closest neigh is greater than first angle */
|
||||
if (dir_dot>closest_d[1] && closest_dot<closest_d[0] && dir_dot>0.0f) {closest_d[1]=dir_dot; closest_id[1]=n_index;}
|
||||
}
|
||||
@ -3983,7 +3983,7 @@ void surface_determineForceTargetPoints(PaintSurfaceData *sData, int index, floa
|
||||
closest_d[1] *= acosf(temp)/1.57079633f;
|
||||
}
|
||||
else {
|
||||
/* if only single neighbour, still linearize force intersection effect */
|
||||
/* if only single neighbor, still linearize force intersection effect */
|
||||
closest_d[0] = 1.0f - acosf(closest_d[0])/1.57079633f;
|
||||
}
|
||||
}
|
||||
@ -4177,7 +4177,7 @@ static void dynamicPaint_doEffectStep(DynamicPaintSurface *surface, float *force
|
||||
/* Only reads values from the surface copy (prevPoint[]),
|
||||
* so this one is thread safe */
|
||||
|
||||
/* Loop through neighbouring points */
|
||||
/* Loop through neighboring points */
|
||||
for (i=0; i<numOfNeighs; i++) {
|
||||
int n_index = sData->adj_data->n_index[index]+i;
|
||||
float w_factor;
|
||||
@ -4226,7 +4226,7 @@ static void dynamicPaint_doEffectStep(DynamicPaintSurface *surface, float *force
|
||||
|
||||
totalAlpha += ePoint->e_alpha;
|
||||
|
||||
/* Check if neighbouring point has lower alpha,
|
||||
/* Check if neighboring point has lower alpha,
|
||||
* if so, decrease this point's alpha as well*/
|
||||
if (pPoint->alpha <= 0.0f && pPoint->e_alpha <= 0.0f && pPoint->wetness <= 0.0f) continue;
|
||||
|
||||
|
@ -99,7 +99,7 @@ static FModifierTypeInfo FMI_MODNAME = {
|
||||
/* Generators available:
|
||||
* 1) simple polynomial generator:
|
||||
* - Exanded form - (y = C[0]*(x^(n)) + C[1]*(x^(n-1)) + ... + C[n])
|
||||
* - Factorised form - (y = (C[0][0]*x + C[0][1]) * (C[1][0]*x + C[1][1]) * ... * (C[n][0]*x + C[n][1]))
|
||||
* - Factorized form - (y = (C[0][0]*x + C[0][1]) * (C[1][0]*x + C[1][1]) * ... * (C[n][0]*x + C[n][1]))
|
||||
*/
|
||||
|
||||
static void fcm_generator_free (FModifier *fcm)
|
||||
@ -198,7 +198,7 @@ static void fcm_generator_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, float *
|
||||
{
|
||||
FMod_Generator *data= (FMod_Generator *)fcm->data;
|
||||
|
||||
/* behaviour depends on mode
|
||||
/* behavior depends on mode
|
||||
* NOTE: the data in its default state is fine too
|
||||
*/
|
||||
switch (data->mode) {
|
||||
@ -238,7 +238,7 @@ static void fcm_generator_evaluate (FCurve *UNUSED(fcu), FModifier *fcm, float *
|
||||
}
|
||||
break;
|
||||
|
||||
case FCM_GENERATOR_POLYNOMIAL_FACTORISED: /* factorised polynomial */
|
||||
case FCM_GENERATOR_POLYNOMIAL_FACTORISED: /* Factorized polynomial */
|
||||
{
|
||||
float value= 1.0f, *cp=NULL;
|
||||
unsigned int i;
|
||||
@ -506,13 +506,15 @@ static FModifierTypeInfo FMI_ENVELOPE = {
|
||||
/* Cycles F-Curve Modifier --------------------------- */
|
||||
|
||||
/* This modifier changes evaltime to something that exists within the curve's frame-range,
|
||||
* then re-evaluates modifier stack up to this point using the new time. This re-entrant behaviour
|
||||
* is very likely to be more time-consuming than the original approach... (which was tighly integrated into
|
||||
* then re-evaluates modifier stack up to this point using the new time. This re-entrant behavior
|
||||
* is very likely to be more time-consuming than the original approach... (which was tightly integrated into
|
||||
* the calculation code...).
|
||||
*
|
||||
* NOTE: this needs to be at the start of the stack to be of use, as it needs to know the extents of the keyframes/sample-data
|
||||
* Possible TODO - store length of cycle information that can be initialised from the extents of the keyframes/sample-data, and adjusted
|
||||
* as appropriate
|
||||
* NOTE: this needs to be at the start of the stack to be of use, as it needs to know the extents of the
|
||||
* keyframes/sample-data.
|
||||
*
|
||||
* Possible TODO - store length of cycle information that can be initialised from the extents of the
|
||||
* keyframes/sample-data, and adjusted as appropriate.
|
||||
*/
|
||||
|
||||
/* temp data used during evaluation */
|
||||
|
@ -608,7 +608,7 @@ IDProperty *IDP_GetProperties(ID *id, int create_if_needed)
|
||||
if (create_if_needed) {
|
||||
id->properties = MEM_callocN(sizeof(IDProperty), "IDProperty");
|
||||
id->properties->type = IDP_GROUP;
|
||||
/* dont overwite the data's name and type
|
||||
/* dont overwrite the data's name and type
|
||||
* some functions might need this if they
|
||||
* dont have a real ID, should be named elsewhere - Campbell */
|
||||
/* strcpy(id->name, "top_level_group");*/
|
||||
|
@ -1886,7 +1886,7 @@ int do_version_tface(Main *main, int fileload)
|
||||
ma->game.flag = -flag;
|
||||
|
||||
/* some people uses multitexture with TexFace by creating a texture
|
||||
* channel which not neccessarly the tf->tpage image. But the game engine
|
||||
* channel which not necessarily the tf->tpage image. But the game engine
|
||||
* was enabling it. Now it's required to set "Face Texture [Alpha] in the
|
||||
* material settings. */
|
||||
if (!fileload)
|
||||
|
@ -2343,7 +2343,7 @@ int mesh_recalcTesselation(CustomData *fdata,
|
||||
mf->flag = mp->flag;
|
||||
|
||||
#ifdef USE_TESSFACE_SPEEDUP
|
||||
mf->edcode |= TESSFACE_SCANFILL; /* tag for sorting loop indicies */
|
||||
mf->edcode |= TESSFACE_SCANFILL; /* tag for sorting loop indices */
|
||||
#endif
|
||||
|
||||
if (poly_orig_index) {
|
||||
|
@ -286,7 +286,7 @@ NlaStrip *add_nlastrip (bAction *act)
|
||||
* - selected flag to highlight this to the user
|
||||
* - auto-blends to ensure that blend in/out values are automatically
|
||||
* determined by overlaps of strips
|
||||
* - (XXX) synchronisation of strip-length in accordance with changes to action-length
|
||||
* - (XXX) synchronization of strip-length in accordance with changes to action-length
|
||||
* is not done though, since this should only really happens in editmode for strips now
|
||||
* though this decision is still subject to further review...
|
||||
*/
|
||||
@ -778,7 +778,7 @@ short BKE_nlameta_add_strip (NlaStrip *mstrip, NlaStrip *strip)
|
||||
return 0;
|
||||
|
||||
/* check if this would need to be added to the ends of the meta,
|
||||
* and subsequently, if the neighbouring strips allow us enough room
|
||||
* and subsequently, if the neighboring strips allow us enough room
|
||||
*/
|
||||
if (strip->start < mstrip->start) {
|
||||
/* check if strip to the left (if it exists) ends before the
|
||||
@ -1235,7 +1235,7 @@ void BKE_nlastrip_validate_fcurves (NlaStrip *strip)
|
||||
/* store path - make copy, and store that */
|
||||
fcu->rna_path= BLI_strdupn("influence", 9);
|
||||
|
||||
// TODO: insert a few keyframes to ensure default behaviour?
|
||||
// TODO: insert a few keyframes to ensure default behavior?
|
||||
}
|
||||
}
|
||||
|
||||
@ -1256,7 +1256,7 @@ void BKE_nlastrip_validate_fcurves (NlaStrip *strip)
|
||||
/* store path - make copy, and store that */
|
||||
fcu->rna_path= BLI_strdupn("strip_time", 10);
|
||||
|
||||
// TODO: insert a few keyframes to ensure default behaviour?
|
||||
// TODO: insert a few keyframes to ensure default behavior?
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -991,7 +991,7 @@ void ntreeSetOutput(bNodeTree *ntree)
|
||||
{
|
||||
bNode *node;
|
||||
|
||||
/* find the active outputs, might become tree type dependant handler */
|
||||
/* find the active outputs, might become tree type dependent handler */
|
||||
for(node= ntree->nodes.first; node; node= node->next) {
|
||||
if(node->typeinfo->nclass==NODE_CLASS_OUTPUT) {
|
||||
bNode *tnode;
|
||||
|
@ -170,7 +170,7 @@ static float gaussRand (void)
|
||||
}
|
||||
|
||||
/**
|
||||
* Som usefull functions
|
||||
* Some useful functions
|
||||
* */
|
||||
MINLINE float lerp(float a,float b,float f)
|
||||
{
|
||||
|
@ -2874,10 +2874,12 @@ static void cache_key_incremental_rotation(ParticleCacheKey *key0, ParticleCache
|
||||
copy_v3_v3(prev_tangent, tangent);
|
||||
}
|
||||
}
|
||||
/* Calculates paths ready for drawing/rendering. */
|
||||
/* -Usefull for making use of opengl vertex arrays for super fast strand drawing. */
|
||||
/* -Makes child strands possible and creates them too into the cache. */
|
||||
/* -Cached path data is also used to determine cut position for the editmode tool. */
|
||||
|
||||
/**
|
||||
* Calculates paths ready for drawing/rendering
|
||||
* - Useful for making use of opengl vertex arrays for super fast strand drawing.
|
||||
* - Makes child strands possible and creates them too into the cache.
|
||||
* - Cached path data is also used to determine cut position for the editmode tool. */
|
||||
void psys_cache_paths(ParticleSimulationData *sim, float cfra)
|
||||
{
|
||||
PARTICLE_PSMD;
|
||||
|
@ -974,7 +974,7 @@ static int distribute_compare_orig_index(const void *p1, const void *p2)
|
||||
return -1;
|
||||
else if(index1 == index2) {
|
||||
/* this pointer comparison appears to make qsort stable for glibc,
|
||||
* and apparently on solaris too, makes the renders reproducable */
|
||||
* and apparently on solaris too, makes the renders reproducible */
|
||||
if(p1 < p2)
|
||||
return -1;
|
||||
else if(p1 == p2)
|
||||
|
@ -306,7 +306,7 @@ static void shrinkwrap_calc_normal_projection(ShrinkwrapCalcData *calc)
|
||||
else
|
||||
{
|
||||
//The code supports any axis that is a combination of X,Y,Z
|
||||
//altought currently UI only allows to set the 3 diferent axis
|
||||
//altought currently UI only allows to set the 3 different axis
|
||||
if(calc->smd->projAxis & MOD_SHRINKWRAP_PROJECT_OVER_X_AXIS) proj_axis[0] = 1.0f;
|
||||
if(calc->smd->projAxis & MOD_SHRINKWRAP_PROJECT_OVER_Y_AXIS) proj_axis[1] = 1.0f;
|
||||
if(calc->smd->projAxis & MOD_SHRINKWRAP_PROJECT_OVER_Z_AXIS) proj_axis[2] = 1.0f;
|
||||
@ -405,7 +405,7 @@ static void shrinkwrap_calc_normal_projection(ShrinkwrapCalcData *calc)
|
||||
* Shrinkwrap moving vertexs to the nearest surface point on the target
|
||||
*
|
||||
* it builds a BVHTree from the target mesh and then performs a
|
||||
* NN matchs for each vertex
|
||||
* NN matches for each vertex
|
||||
*/
|
||||
static void shrinkwrap_calc_nearest_surface_point(ShrinkwrapCalcData *calc)
|
||||
{
|
||||
|
@ -1163,7 +1163,7 @@ static void smoke_calc_domain(Scene *scene, Object *ob, SmokeModifierData *smd)
|
||||
for(z = 0; z < sds->res[2]; z++)
|
||||
{
|
||||
|
||||
// neighbour cell emission densities (for high resolution smoke smooth interpolation)
|
||||
// neighbor cell emission densities (for high resolution smoke smooth interpolation)
|
||||
float c000, c001, c010, c011, c100, c101, c110, c111;
|
||||
|
||||
c000 = (x>0 && y>0 && z>0) ? temp_emission_map[smoke_get_index(x-1, sds->res[0], y-1, sds->res[1], z-1)] : 0;
|
||||
|
@ -988,7 +988,7 @@ static void Vec3PlusStVec(float *v, float s, float *v1)
|
||||
v[2] += s*v1[2];
|
||||
}
|
||||
|
||||
/* +++ dependancy information functions*/
|
||||
/* +++ dependency information functions*/
|
||||
|
||||
static int are_there_deflectors(Scene *scene, unsigned int layer)
|
||||
{
|
||||
@ -1007,7 +1007,7 @@ static int query_external_colliders(Scene *scene, Object *me)
|
||||
{
|
||||
return(are_there_deflectors(scene, me->lay));
|
||||
}
|
||||
/* --- dependancy information functions*/
|
||||
/* --- dependency information functions*/
|
||||
|
||||
|
||||
/* +++ the aabb "force" section*/
|
||||
@ -1606,7 +1606,7 @@ static void _scan_for_ext_spring_forces(Scene *scene, Object *ob, float timenow,
|
||||
}
|
||||
f = normalize_v3(vel);
|
||||
f = -0.0001f*f*f*sb->aeroedge;
|
||||
/* (todo) add a nice angle dependant function done for now BUT */
|
||||
/* (todo) add a nice angle dependent function done for now BUT */
|
||||
/* still there could be some nice drag/lift function, but who needs it */
|
||||
|
||||
sub_v3_v3v3(sp, sb->bpoint[bs->v1].pos , sb->bpoint[bs->v2].pos);
|
||||
|
@ -3343,7 +3343,7 @@ struct DerivedMesh *subsurf_make_derived_from_derived(
|
||||
CCGSubSurf *ss;
|
||||
|
||||
/* It is quite possible there is a much better place to do this. It
|
||||
* depends a bit on how rigourously we expect this function to never
|
||||
* depends a bit on how rigorously we expect this function to never
|
||||
* be called in editmode. In semi-theory we could share a single
|
||||
* cache, but the handles used inside and outside editmode are not
|
||||
* the same so we would need some way of converting them. Its probably
|
||||
|
@ -90,7 +90,7 @@ be popped ... other st's retain their own top location.
|
||||
|
||||
Markers
|
||||
--
|
||||
The mrk->flags define the behaviour and relationships between markers. The
|
||||
The mrk->flags define the behavior and relationships between markers. The
|
||||
upper two bytes are used to hold a group ID, the lower two are normal flags. If
|
||||
TMARK_EDITALL is set the group ID defines which other markers should be edited.
|
||||
|
||||
@ -2617,7 +2617,7 @@ void txt_backspace_word (Text *text)
|
||||
}
|
||||
|
||||
/* Max spaces to replace a tab with, currently hardcoded to TXT_TABSIZE = 4.
|
||||
* Used by txt_convert_tab_to_spaces, indent and unintent.
|
||||
* Used by txt_convert_tab_to_spaces, indent and unindent.
|
||||
* Remember to change this string according to max tab size */
|
||||
static char tab_to_spaces[] = " ";
|
||||
|
||||
|
@ -944,7 +944,7 @@ MovieTrackingContext *BKE_tracking_context_new(MovieClip *clip, MovieClipUser *u
|
||||
float log2_search_to_pattern_ratio = log(floor(search_to_pattern_ratio)) / M_LN2;
|
||||
int max_pyramid_levels= floor(log2_search_to_pattern_ratio + 1);
|
||||
|
||||
/* try to accomodate the user's choice of pyramid level in a way
|
||||
/* try to accommodate the user's choice of pyramid level in a way
|
||||
* that doesn't cause the coarsest pyramid pattern to be larger
|
||||
* than the search size */
|
||||
int level= MIN2(track->pyramid_levels, max_pyramid_levels);
|
||||
|
@ -51,7 +51,7 @@
|
||||
*
|
||||
* arrays are buffered, using double-buffering (so on each reallocation,
|
||||
* the array size is doubled). supposedly this should give good Big Oh
|
||||
* behaviour, though it may not be the best in practice.
|
||||
* behavior, though it may not be the best in practice.
|
||||
*/
|
||||
|
||||
#define BLI_array_declare(arr) \
|
||||
|
@ -77,7 +77,7 @@ typedef struct DLRBT_Tree {
|
||||
|
||||
/* return -1, 0, 1 for whether the given data is less than, equal to, or greater than the given node
|
||||
* - node: <DLRBT_Node> the node to compare to
|
||||
* - data: pointer to the relevant data or values stored in the bitpattern dependant on the function
|
||||
* - data: pointer to the relevant data or values stored in the bitpattern dependent on the function
|
||||
*/
|
||||
typedef short (*DLRBT_Comparator_FP)(void *node, void *data);
|
||||
|
||||
@ -88,7 +88,7 @@ typedef DLRBT_Node *(*DLRBT_NAlloc_FP)(void *data);
|
||||
|
||||
/* update an existing node instance accordingly to be in sync with the given data *
|
||||
* - node: <DLRBT_Node> the node to update
|
||||
* - data: pointer to the relevant data or values stored in the bitpattern dependant on the function
|
||||
* - data: pointer to the relevant data or values stored in the bitpattern dependent on the function
|
||||
*/
|
||||
typedef void (*DLRBT_NUpdate_FP)(void *node, void *data);
|
||||
|
||||
|
@ -31,7 +31,7 @@
|
||||
|
||||
/** \file BLI_kdtree.h
|
||||
* \ingroup bli
|
||||
* \brief A kd-tree for nearest neighbour search.
|
||||
* \brief A kd-tree for nearest neighbor search.
|
||||
* \author Janne Karhu
|
||||
* \author Brecht van Lommel
|
||||
*/
|
||||
|
@ -92,7 +92,7 @@ char *BLI_getQuotedStr(const char *str, const char *prefix);
|
||||
* string with all instances of oldText replaced with newText,
|
||||
* and returns it.
|
||||
*
|
||||
* @param str The string to replace occurances of oldText in
|
||||
* @param str The string to replace occurrences of oldText in
|
||||
* @param oldText The text in the string to find and replace
|
||||
* @param newText The text in the string to find and replace
|
||||
* @retval Returns the duplicated string
|
||||
|
@ -42,7 +42,7 @@ extern "C" {
|
||||
extern
|
||||
/** Return an indication of time, expressed as
|
||||
* seconds since some fixed point. Successive calls
|
||||
* are guarenteed to generate values greator than or
|
||||
* are guarenteed to generate values greater than or
|
||||
* equal to the last call.
|
||||
*/
|
||||
double PIL_check_seconds_timer (void);
|
||||
|
@ -663,7 +663,7 @@ static int implicit_leafs_index(BVHBuildHelper *data, int depth, int child_index
|
||||
* Advantages of the used trees include:
|
||||
* - No need to store child/parent relations (they are implicit);
|
||||
* - Any node child always has an index greater than the parent;
|
||||
* - Brother nodes are sequencial in memory;
|
||||
* - Brother nodes are sequential in memory;
|
||||
*
|
||||
*
|
||||
* Some math relations derived for general implicit trees:
|
||||
@ -688,7 +688,7 @@ static int implicit_needed_branches(int tree_type, int leafs)
|
||||
*
|
||||
* It arranges the elements in the given partitions such that:
|
||||
* - any element in partition N is less or equal to any element in partition N+1.
|
||||
* - if all elements are diferent all partition will get the same subset of elements
|
||||
* - if all elements are different all partition will get the same subset of elements
|
||||
* as if the array was sorted.
|
||||
*
|
||||
* partition P is described as the elements in the range ( nth[P] , nth[P+1] ]
|
||||
|
@ -295,7 +295,7 @@ void boxPack2D(boxPack *boxarray, const int len, float *tot_width, float *tot_he
|
||||
isect = 1;
|
||||
} else {
|
||||
/* do a full search for colliding box
|
||||
* this is really slow, some spacialy divided
|
||||
* this is really slow, some spatially divided
|
||||
* data-structure would be better */
|
||||
for (box_test=boxarray; box_test != box; box_test++) {
|
||||
if BOXINTERSECT(box, box_test) {
|
||||
|
@ -850,7 +850,7 @@ int isect_line_plane_v3(float out[3], const float l1[3], const float l2[3], cons
|
||||
float l1_plane[3]; /* line point aligned with the plane */
|
||||
float dist; /* 'plane_no' aligned distance to the 'plane_co' */
|
||||
|
||||
/* for pradictable flipping since the plane is only used to
|
||||
/* for predictable flipping since the plane is only used to
|
||||
* define a direction, ignore its flipping and aligned with 'l_vec' */
|
||||
if(dot < 0.0f) {
|
||||
dot= -dot;
|
||||
|
@ -378,8 +378,8 @@ void BLI_cleanup_path(const char *relabase, char *dir)
|
||||
}
|
||||
|
||||
/* support for odd paths: eg /../home/me --> /home/me
|
||||
* this is a valid path in blender but we cant handle this the useual way below
|
||||
* simply strip this prefix then evaluate the path as useual. pythons os.path.normpath() does this */
|
||||
* this is a valid path in blender but we cant handle this the usual way below
|
||||
* simply strip this prefix then evaluate the path as usual. pythons os.path.normpath() does this */
|
||||
while((strncmp(dir, "/../", 4)==0)) {
|
||||
memmove( dir, dir + 4, strlen(dir + 4) + 1 );
|
||||
}
|
||||
@ -1571,7 +1571,7 @@ char *BLI_path_basename(char *path)
|
||||
|
||||
This logic will help ensure that all image paths are relative and
|
||||
that a user gets his images in one place. It'll also provide
|
||||
consistent behaviour across exporters.
|
||||
consistent behavior across exporters.
|
||||
*/
|
||||
int BKE_rebase_path(char *abs, size_t abs_len, char *rel, size_t rel_len, const char *base_dir, const char *src_dir, const char *dest_dir)
|
||||
{
|
||||
|
@ -184,8 +184,8 @@ char *BLI_getQuotedStr (const char *str, const char *prefix)
|
||||
return BLI_strdupn(startMatch, (size_t)(endMatch-startMatch));
|
||||
}
|
||||
|
||||
/* Replaces all occurances of oldText with newText in str, returning a new string that doesn't
|
||||
* contain the 'replaced' occurances.
|
||||
/* Replaces all occurrences of oldText with newText in str, returning a new string that doesn't
|
||||
* contain the 'replaced' occurrences.
|
||||
*/
|
||||
// A rather wasteful string-replacement utility, though this shall do for now...
|
||||
// Feel free to replace this with an even safe + nicer alternative
|
||||
@ -231,7 +231,7 @@ char *BLI_replacestr(char *str, const char *oldText, const char *newText)
|
||||
str += lenOld;
|
||||
}
|
||||
|
||||
/* finish off and return a new string that has had all occurances of */
|
||||
/* finish off and return a new string that has had all occurrences of */
|
||||
if (ds) {
|
||||
char *newStr;
|
||||
|
||||
|
@ -43,7 +43,7 @@ BM_INLINE float D(float *data, const int res[3], int x, int y, int z)
|
||||
return data[ V_I(x, y, z, res) ];
|
||||
}
|
||||
|
||||
/* *** nearest neighbour *** */
|
||||
/* *** nearest neighbor *** */
|
||||
/* input coordinates must be in bounding box 0.0 - 1.0 */
|
||||
float voxel_sample_nearest(float *data, const int res[3], const float co[3])
|
||||
{
|
||||
|
@ -8372,7 +8372,7 @@ static void do_versions(FileData *fd, Library *lib, Main *main)
|
||||
ob = main->object.first;
|
||||
|
||||
/* adapt form factor in order to get the 'old' physics
|
||||
* behaviour back...*/
|
||||
* behavior back...*/
|
||||
|
||||
while (ob) {
|
||||
/* in future, distinguish between different
|
||||
@ -10724,7 +10724,7 @@ static void do_versions(FileData *fd, Library *lib, Main *main)
|
||||
ob->m_contactProcessingThreshold = 1.; //pad3 is used for m_contactProcessingThreshold
|
||||
if(ob->parent) {
|
||||
/* check if top parent has compound shape set and if yes, set this object
|
||||
to compound shaper as well (was the behaviour before, now it's optional) */
|
||||
to compound shaper as well (was the behavior before, now it's optional) */
|
||||
Object *parent= newlibadr(fd, lib, ob->parent);
|
||||
while (parent && parent != ob && parent->parent != NULL) {
|
||||
parent = newlibadr(fd, lib, parent->parent);
|
||||
@ -10865,7 +10865,7 @@ static void do_versions(FileData *fd, Library *lib, Main *main)
|
||||
do_versions_gpencil_2_50(main, screen);
|
||||
}
|
||||
|
||||
/* shader, composit and texture node trees have id.name empty, put something in
|
||||
/* shader, composite and texture node trees have id.name empty, put something in
|
||||
* to have them show in RNA viewer and accessible otherwise.
|
||||
*/
|
||||
for(ma= main->mat.first; ma; ma= ma->id.next) {
|
||||
@ -10881,7 +10881,7 @@ static void do_versions(FileData *fd, Library *lib, Main *main)
|
||||
}
|
||||
}
|
||||
}
|
||||
/* and composit trees */
|
||||
/* and composite trees */
|
||||
for(sce= main->scene.first; sce; sce= sce->id.next) {
|
||||
if(sce->nodetree && sce->nodetree->id.name[0] == '\0')
|
||||
strcpy(sce->nodetree->id.name, "NTCompositing Nodetree");
|
||||
@ -11274,7 +11274,7 @@ static void do_versions(FileData *fd, Library *lib, Main *main)
|
||||
Object *ob;
|
||||
Lamp *la;
|
||||
|
||||
/* New variables for axis-angle rotations and/or quaternion rotations were added, and need proper initialisation */
|
||||
/* New variables for axis-angle rotations and/or quaternion rotations were added, and need proper initialization */
|
||||
for (ob= main->object.first; ob; ob= ob->id.next) {
|
||||
/* new variables for all objects */
|
||||
ob->quat[0]= 1.0f;
|
||||
@ -11623,7 +11623,7 @@ static void do_versions(FileData *fd, Library *lib, Main *main)
|
||||
animviz_settings_init(&ob->avs);
|
||||
|
||||
/* if armature, copy settings for pose from armature data
|
||||
* performing initialisation where appropriate
|
||||
* performing initialization where appropriate
|
||||
*/
|
||||
if (ob->pose && ob->data) {
|
||||
bArmature *arm= newlibadr(fd, lib, ob->data);
|
||||
@ -12382,7 +12382,7 @@ static void do_versions(FileData *fd, Library *lib, Main *main)
|
||||
bNodeTree *ntree;
|
||||
|
||||
/* node sockets are not exposed automatically any more,
|
||||
* this mimics the old behaviour by adding all unlinked sockets to groups.
|
||||
* this mimics the old behavior by adding all unlinked sockets to groups.
|
||||
*/
|
||||
for (ntree=main->nodetree.first; ntree; ntree=ntree->id.next) {
|
||||
/* XXX Only setting a flag here. Actual adding of group sockets
|
||||
|
@ -281,7 +281,7 @@ BM_INLINE void _bm_elem_flag_merge(BMHeader *head_a, BMHeader *head_b);
|
||||
* sure if the index values are valid because certain operations have modified
|
||||
* the mesh structure.
|
||||
*
|
||||
* To set the elements to valid indicies 'BM_mesh_elem_index_ensure' should be used
|
||||
* To set the elements to valid indices 'BM_mesh_elem_index_ensure' should be used
|
||||
* rather then adding inline loops, however there are cases where we still
|
||||
* set the index directly
|
||||
*
|
||||
|
@ -1791,7 +1791,7 @@ static int bm_vert_cut(BMesh *bm, BMVert *v, BMVert ***vout, int *len)
|
||||
continue;
|
||||
}
|
||||
|
||||
/* Loops here should alway refer to an edge that has v as an
|
||||
/* Loops here should always refer to an edge that has v as an
|
||||
* endpoint. For each appearance of this vert in a face, there
|
||||
* will actually be two iterations: one for the loop heading
|
||||
* towards vertex v, and another for the loop heading out from
|
||||
|
@ -619,7 +619,7 @@ void BM_editselection_plane(BMesh *bm, float r_plane[3], BMEditSelection *ese)
|
||||
* however selecting different edges can swap the direction of the y axis.
|
||||
* this makes it less likely for the y axis of the manipulator
|
||||
* (running along the edge).. to flip less often.
|
||||
* at least its more pradictable */
|
||||
* at least its more predictable */
|
||||
if (eed->v2->co[1] > eed->v1->co[1]) { /* check which to do first */
|
||||
sub_v3_v3v3(r_plane, eed->v2->co, eed->v1->co);
|
||||
}
|
||||
@ -854,7 +854,7 @@ void BM_edge_hide_set(BMesh *bm, BMEdge *e, int hide)
|
||||
|
||||
BM_elem_flag_set(e, BM_ELEM_HIDDEN, hide);
|
||||
|
||||
/* hide vertices if necassary */
|
||||
/* hide vertices if necessary */
|
||||
vert_flush_hide_set(bm, e->v1);
|
||||
vert_flush_hide_set(bm, e->v2);
|
||||
}
|
||||
|
@ -145,7 +145,7 @@ void BM_mesh_data_free(BMesh *bm)
|
||||
BLI_mempool_destroy(bm->looplistpool);
|
||||
#endif
|
||||
|
||||
/* These tables aren't used yet, so it's not stricly necessary
|
||||
/* These tables aren't used yet, so it's not strictly necessary
|
||||
* to 'end' them (with 'e' param) but if someone tries to start
|
||||
* using them, having these in place will save a lot of pain */
|
||||
mesh_octree_table(NULL, NULL, NULL, 'e');
|
||||
|
@ -206,7 +206,7 @@ int BM_disk_dissolve(BMesh *bm, BMVert *v)
|
||||
/**
|
||||
* \brief Faces Join Pair
|
||||
*
|
||||
* Joins two adjacenct faces togather.
|
||||
* Joins two adjacent faces togather.
|
||||
*
|
||||
* Because this method calls to #BM_faces_join to do its work, if a pair
|
||||
* of faces share multiple edges, the pair of faces will be joined at
|
||||
|
@ -353,7 +353,7 @@ static BMOpDefine bmo_weldverts_def = {
|
||||
/*
|
||||
* Make Vertex
|
||||
*
|
||||
* Creates a single vertex; this bmop was necassary
|
||||
* Creates a single vertex; this bmop was necessary
|
||||
* for click-create-vertex.
|
||||
*/
|
||||
static BMOpDefine bmo_makevert_def = {
|
||||
@ -454,7 +454,7 @@ static BMOpDefine bmo_edgenet_prepare_def = {
|
||||
* Rotate
|
||||
*
|
||||
* Rotate vertices around a center, using a 3x3 rotation
|
||||
* matrix. Equivilent of the old rotateflag function.
|
||||
* matrix. Equivalent of the old rotateflag function.
|
||||
*/
|
||||
static BMOpDefine bmo_rotate_def = {
|
||||
"rotate",
|
||||
@ -469,7 +469,7 @@ static BMOpDefine bmo_rotate_def = {
|
||||
/*
|
||||
* Translate
|
||||
*
|
||||
* Translate vertices by an offset. Equivelent of the
|
||||
* Translate vertices by an offset. Equivalent of the
|
||||
* old translateflag function.
|
||||
*/
|
||||
static BMOpDefine bmo_translate_def = {
|
||||
|
@ -80,7 +80,7 @@ BM_INLINE void BMO_slot_map_float_insert(BMesh *bm, BMOperator *op, const char *
|
||||
}
|
||||
|
||||
|
||||
/* pointer versoins of BMO_slot_map_float_get and BMO_slot_map_float_insert.
|
||||
/* pointer versions of BMO_slot_map_float_get and BMO_slot_map_float_insert.
|
||||
*
|
||||
* do NOT use these for non-operator-api-allocated memory! instead
|
||||
* use BMO_slot_map_data_get and BMO_slot_map_insert, which copies the data. */
|
||||
|
@ -107,7 +107,7 @@ int bmesh_edge_swapverts(BMEdge *e, BMVert *orig, BMVert *newv)
|
||||
* some nice utilities for navigating disk cycles in a way that hides this detail from the
|
||||
* tool writer.
|
||||
*
|
||||
* Note that the disk cycle is completley independent from face data. One advantage of this
|
||||
* Note that the disk cycle is completely independent from face data. One advantage of this
|
||||
* is that wire edges are fully integrated into the topology database. Another is that the
|
||||
* the disk cycle has no problems dealing with non-manifold conditions involving faces.
|
||||
*
|
||||
@ -152,7 +152,7 @@ int bmesh_edge_swapverts(BMEdge *e, BMVert *orig, BMVert *newv)
|
||||
*
|
||||
* \note the order of elements in all cycles except the loop cycle is undefined. This
|
||||
* leads to slightly increased seek time for deriving some adjacency relations, however the
|
||||
* advantage is that no intrinsic properties of the data structures are dependant upon the
|
||||
* advantage is that no intrinsic properties of the data structures are dependent upon the
|
||||
* cycle order and all non-manifold conditions are represented trivially.
|
||||
*/
|
||||
int bmesh_disk_edge_append(BMEdge *e, BMVert *v)
|
||||
|
@ -35,7 +35,7 @@
|
||||
* None of these functions should ever be exported to the rest of Blender.
|
||||
*
|
||||
* in the vast majority of cases thes should not be used directly.
|
||||
* if absolutely necassary, see function defitions in code for
|
||||
* if absolutely necessary, see function definitions in code for
|
||||
* descriptive comments. but seriously, don't use this stuff.
|
||||
*/
|
||||
|
||||
|
@ -42,7 +42,7 @@
|
||||
*
|
||||
* original desing: walkers directly emulation recursive functions.
|
||||
* functions save their state onto a worklist, and also add new states
|
||||
* to implement recursive or looping behaviour. generally only one
|
||||
* to implement recursive or looping behavior. generally only one
|
||||
* state push per call with a specific state is desired.
|
||||
*
|
||||
* basic design pattern: the walker step function goes through it's
|
||||
@ -53,8 +53,8 @@
|
||||
* - Walkers use tool flags, not header flags.
|
||||
* - Walkers now use ghash for storing visited elements,
|
||||
* rather then stealing flags. ghash can be rewritten
|
||||
* to be faster if necassary, in the far future :) .
|
||||
* - tools should ALWAYS have necassary error handling
|
||||
* to be faster if necessary, in the far future :) .
|
||||
* - tools should ALWAYS have necessary error handling
|
||||
* for if walkers fail.
|
||||
*/
|
||||
|
||||
|
@ -787,7 +787,7 @@ static void *uvedgeWalker_step(BMWalker *walker)
|
||||
return l;
|
||||
|
||||
/* go over loops around l->v and nl->v and see which ones share l and nl's
|
||||
* mloopuv's coordinates. in addition, push on l->next if necassary */
|
||||
* mloopuv's coordinates. in addition, push on l->next if necessary */
|
||||
for (i = 0; i < 2; i++) {
|
||||
cl = i ? nl : l;
|
||||
BM_ITER(l2, &liter, walker->bm, BM_LOOPS_OF_VERT, cl->v) {
|
||||
|
@ -298,7 +298,7 @@ void bmo_edgesplit_exec(BMesh *bm, BMOperator *op)
|
||||
}
|
||||
else {
|
||||
/* generate unique vert for non-seam edge(s)
|
||||
* around the manifold vert fan if necassary */
|
||||
* around the manifold vert fan if necessary */
|
||||
|
||||
/* first check that we have two seam edges
|
||||
* somewhere within this fa */
|
||||
|
@ -150,7 +150,7 @@ void bmo_mesh_to_bmesh_exec(BMesh *bm, BMOperator *op)
|
||||
/* transfer flag */
|
||||
v->head.hflag = BM_vert_flag_from_mflag(mvert->flag);
|
||||
|
||||
/* this is necassary for selection counts to work properl */
|
||||
/* this is necessary for selection counts to work properl */
|
||||
if (BM_elem_flag_test(v, BM_ELEM_SELECT)) BM_vert_select_set(bm, v, TRUE);
|
||||
|
||||
normal_short_to_float_v3(v->no, mvert->no);
|
||||
@ -196,7 +196,7 @@ void bmo_mesh_to_bmesh_exec(BMesh *bm, BMOperator *op)
|
||||
/* transfer flags */
|
||||
e->head.hflag = BM_edge_flag_from_mflag(medge->flag);
|
||||
|
||||
/* this is necassary for selection counts to work properly */
|
||||
/* this is necessary for selection counts to work properly */
|
||||
if (BM_elem_flag_test(e, BM_ELEM_SELECT)) BM_elem_select_set(bm, e, TRUE);
|
||||
|
||||
/* Copy Custom Dat */
|
||||
@ -260,7 +260,7 @@ void bmo_mesh_to_bmesh_exec(BMesh *bm, BMOperator *op)
|
||||
/* transfer flag */
|
||||
f->head.hflag = BM_face_flag_from_mflag(mpoly->flag);
|
||||
|
||||
/* this is necassary for selection counts to work properl */
|
||||
/* this is necessary for selection counts to work properl */
|
||||
if (BM_elem_flag_test(f, BM_ELEM_SELECT)) BM_elem_select_set(bm, f, TRUE);
|
||||
|
||||
f->mat_nr = mpoly->mat_nr;
|
||||
@ -688,7 +688,7 @@ void bmo_bmesh_to_mesh_exec(BMesh *bm, BMOperator *op)
|
||||
|
||||
/* go through and find any shapekey customdata layers
|
||||
* that might not have corresponding KeyBlocks, and add them if
|
||||
* necassary */
|
||||
* necessary */
|
||||
j = 0;
|
||||
for (i = 0; i < bm->vdata.totlayer; i++) {
|
||||
if (bm->vdata.layers[i].type != CD_SHAPEKEY)
|
||||
|
@ -258,7 +258,7 @@ static void bm_subdivide_multicut(BMesh *bm, BMEdge *edge, const subdparams *par
|
||||
alter_co(bm, v2, &temp, params, 1.0, &ov1, &ov2);
|
||||
}
|
||||
|
||||
/* note: the patterns are rotated as necassary to
|
||||
/* note: the patterns are rotated as necessary to
|
||||
* match the input geometry. they're based on the
|
||||
* pre-split state of the face */
|
||||
|
||||
|
@ -2493,7 +2493,7 @@ static bAnimChannelType ACF_GPL =
|
||||
static bAnimChannelType *animchannelTypeInfo[ANIMTYPE_NUM_TYPES];
|
||||
static short ACF_INIT= 1; /* when non-zero, the list needs to be updated */
|
||||
|
||||
/* Initialise type info definitions */
|
||||
/* Initialize type info definitions */
|
||||
static void ANIM_init_channel_typeinfo_data (void)
|
||||
{
|
||||
int type= 0;
|
||||
|
@ -951,7 +951,7 @@ static void split_groups_action_temp (bAction *act, bActionGroup *tgrp)
|
||||
}
|
||||
}
|
||||
|
||||
/* Initialise memory for temp-group */
|
||||
/* Initialize memory for temp-group */
|
||||
memset(tgrp, 0, sizeof(bActionGroup));
|
||||
tgrp->flag |= (AGRP_EXPANDED|AGRP_TEMP);
|
||||
BLI_strncpy(tgrp->name, "#TempGroup", sizeof(tgrp->name));
|
||||
@ -1784,7 +1784,7 @@ static int animchannels_deselectall_exec (bContext *C, wmOperator *op)
|
||||
if (ANIM_animdata_get_context(C, &ac) == 0)
|
||||
return OPERATOR_CANCELLED;
|
||||
|
||||
/* 'standard' behaviour - check if selected, then apply relevant selection */
|
||||
/* 'standard' behavior - check if selected, then apply relevant selection */
|
||||
if (RNA_boolean_get(op->ptr, "invert"))
|
||||
ANIM_deselect_anim_channels(&ac, ac.data, ac.datatype, 0, ACHANNEL_SETFLAG_TOGGLE);
|
||||
else
|
||||
|
@ -189,7 +189,7 @@ static void draw_cfra_number (Scene *scene, View2D *v2d, float cfra, short time)
|
||||
|
||||
/* get timecode string
|
||||
* - padding on str-buf passed so that it doesn't sit on the frame indicator
|
||||
* - power = 0, gives 'standard' behaviour for time
|
||||
* - power = 0, gives 'standard' behavior for time
|
||||
* but power = 1 is required for frames (to get integer frames)
|
||||
*/
|
||||
if (time)
|
||||
|
@ -175,7 +175,7 @@ static void draw_modifier__generator(uiLayout *layout, ID *id, FModifier *fcm, s
|
||||
}
|
||||
break;
|
||||
|
||||
case FCM_GENERATOR_POLYNOMIAL_FACTORISED: /* factorised polynomial expression */
|
||||
case FCM_GENERATOR_POLYNOMIAL_FACTORISED: /* Factorized polynomial expression */
|
||||
{
|
||||
float *cp = NULL;
|
||||
unsigned int i;
|
||||
|
@ -755,7 +755,7 @@ static float visualkey_get_value (PointerRNA *ptr, PropertyRNA *prop, int array_
|
||||
* Use this when validation of necessary animation data is not necessary, since an RNA-pointer to the necessary
|
||||
* data being keyframed, and a pointer to the F-Curve to use have both been provided.
|
||||
*
|
||||
* The flag argument is used for special settings that alter the behaviour of
|
||||
* The flag argument is used for special settings that alter the behavior of
|
||||
* the keyframe insertion. These include the 'visual' keyframing modes, quick refresh,
|
||||
* and extra keyframe filtering.
|
||||
*/
|
||||
@ -874,7 +874,7 @@ short insert_keyframe_direct (ReportList *reports, PointerRNA ptr, PropertyRNA *
|
||||
/* Main Keyframing API call:
|
||||
* Use this when validation of necessary animation data is necessary, since it may not exist yet.
|
||||
*
|
||||
* The flag argument is used for special settings that alter the behaviour of
|
||||
* The flag argument is used for special settings that alter the behavior of
|
||||
* the keyframe insertion. These include the 'visual' keyframing modes, quick refresh,
|
||||
* and extra keyframe filtering.
|
||||
*
|
||||
@ -968,7 +968,7 @@ short insert_keyframe (ReportList *reports, ID *id, bAction *act, const char gro
|
||||
* Use this when validation of necessary animation data isn't necessary as it
|
||||
* already exists. It will delete a keyframe at the current frame.
|
||||
*
|
||||
* The flag argument is used for special settings that alter the behaviour of
|
||||
* The flag argument is used for special settings that alter the behavior of
|
||||
* the keyframe deletion. These include the quick refresh options.
|
||||
*/
|
||||
short delete_keyframe (ReportList *reports, ID *id, bAction *act, const char group[], const char rna_path[], int array_index, float cfra, short UNUSED(flag))
|
||||
@ -1239,8 +1239,8 @@ void ANIM_OT_keyframe_insert_menu (wmOperatorType *ot)
|
||||
RNA_def_property_flag(prop, PROP_HIDDEN);
|
||||
|
||||
/* whether the menu should always be shown
|
||||
* - by default, the menu should only be shown when there is no active Keying Set (2.5 behaviour),
|
||||
* although in some cases it might be useful to always shown (pre 2.5 behaviour)
|
||||
* - by default, the menu should only be shown when there is no active Keying Set (2.5 behavior),
|
||||
* although in some cases it might be useful to always shown (pre 2.5 behavior)
|
||||
*/
|
||||
prop= RNA_def_boolean(ot->srna, "always_prompt", 0, "Always Show Menu", "");
|
||||
RNA_def_property_flag(prop, PROP_HIDDEN);
|
||||
@ -1711,7 +1711,7 @@ short id_frame_has_keyframe (ID *id, float frame, short filter)
|
||||
break;
|
||||
|
||||
case ID_SCE: /* scene */
|
||||
// XXX TODO... for now, just use 'normal' behaviour
|
||||
// XXX TODO... for now, just use 'normal' behavior
|
||||
// break;
|
||||
|
||||
default: /* 'normal type' */
|
||||
|
@ -839,7 +839,7 @@ typedef struct tRKS_DSource {
|
||||
} tRKS_DSource;
|
||||
|
||||
|
||||
/* Iterator used for overriding the behaviour of iterators defined for
|
||||
/* Iterator used for overriding the behavior of iterators defined for
|
||||
* relative Keying Sets, with the main usage of this being operators
|
||||
* requiring Auto Keyframing. Internal Use Only!
|
||||
*/
|
||||
|
@ -4297,7 +4297,7 @@ int ED_do_pose_selectbuffer(Scene *scene, Base *base, unsigned int *buffer, shor
|
||||
* armature object was not active yet.
|
||||
* note, special exception for armature mode so we can do multi-select
|
||||
* we could check for multi-select explicitly but think its fine to
|
||||
* always give pradictable behavior in weight paint mode - campbell */
|
||||
* always give predictable behavior in weight paint mode - campbell */
|
||||
if (!extend || ((ob_act && (ob_act != ob) && (ob_act->mode & OB_MODE_WEIGHT_PAINT)==0))) {
|
||||
ED_pose_deselectall(ob, 0);
|
||||
nearBone->flag |= (BONE_SELECTED|BONE_TIPSEL|BONE_ROOTSEL);
|
||||
|
@ -1799,7 +1799,7 @@ void sk_applyCutGesture(bContext *UNUSED(C), SK_Gesture *gest, SK_Sketch *UNUSED
|
||||
SK_Point pt;
|
||||
|
||||
pt.type = PT_EXACT;
|
||||
pt.mode = PT_PROJECT; /* take mode from neighbouring points */
|
||||
pt.mode = PT_PROJECT; /* take mode from neighboring points */
|
||||
copy_v3_v3(pt.p, isect->p);
|
||||
copy_v3_v3(pt.no, isect->stroke->points[isect->before].no);
|
||||
|
||||
@ -1841,7 +1841,7 @@ void sk_applyTrimGesture(bContext *UNUSED(C), SK_Gesture *gest, SK_Sketch *UNUSE
|
||||
float stroke_dir[3];
|
||||
|
||||
pt.type = PT_EXACT;
|
||||
pt.mode = PT_PROJECT; /* take mode from neighbouring points */
|
||||
pt.mode = PT_PROJECT; /* take mode from neighboring points */
|
||||
copy_v3_v3(pt.p, isect->p);
|
||||
copy_v3_v3(pt.no, isect->stroke->points[isect->before].no);
|
||||
|
||||
|
@ -1494,7 +1494,7 @@ static float meshdeform_boundary_total_weight(MeshDeformBind *mdb, int x, int y,
|
||||
|
||||
a= meshdeform_index(mdb, x, y, z, 0);
|
||||
|
||||
/* count weight for neighbour cells */
|
||||
/* count weight for neighbor cells */
|
||||
for(i=1; i<=6; i++) {
|
||||
if(meshdeform_index(mdb, x, y, z, i) == -1)
|
||||
continue;
|
||||
|
@ -1231,7 +1231,7 @@ static int pose_propagate_exec (bContext *C, wmOperator *op)
|
||||
void POSE_OT_propagate (wmOperatorType *ot)
|
||||
{
|
||||
static EnumPropertyItem terminate_items[]= {
|
||||
{POSE_PROPAGATE_SMART_HOLDS, "WHILE_HELD", 0, "While Held", "Propagate pose to all keyframes after current frame that don't change (Default behaviour)"},
|
||||
{POSE_PROPAGATE_SMART_HOLDS, "WHILE_HELD", 0, "While Held", "Propagate pose to all keyframes after current frame that don't change (Default behavior)"},
|
||||
{POSE_PROPAGATE_NEXT_KEY, "NEXT_KEY", 0, "To Next Keyframe", "Propagate pose to first keyframe following the current frame only"},
|
||||
{POSE_PROPAGATE_LAST_KEY, "LAST_KEY", 0, "To Last Keyframe", "Propagate pose to the last keyframe only (i.e. making action cyclic)"},
|
||||
{POSE_PROPAGATE_BEFORE_FRAME, "BEFORE_FRAME", 0, "Before Frame", "Propagate pose to all keyframes between current frame and 'Frame' property"},
|
||||
|
@ -186,7 +186,7 @@ static int has_poselib_pose_data_poll (bContext *C)
|
||||
|
||||
/* ----------------------------------- */
|
||||
|
||||
/* Initialise a new poselib (whether it is needed or not) */
|
||||
/* Initialize a new poselib (whether it is needed or not) */
|
||||
static bAction *poselib_init_new (Object *ob)
|
||||
{
|
||||
/* sanity checks - only for armatures */
|
||||
@ -201,7 +201,7 @@ static bAction *poselib_init_new (Object *ob)
|
||||
return ob->poselib;
|
||||
}
|
||||
|
||||
/* Initialise a new poselib (checks if that needs to happen) */
|
||||
/* Initialize a new poselib (checks if that needs to happen) */
|
||||
static bAction *poselib_validate (Object *ob)
|
||||
{
|
||||
if (ELEM(NULL, ob, ob->pose))
|
||||
|
@ -1164,7 +1164,7 @@ static int pose_paste_exec (bContext *C, wmOperator *op)
|
||||
}
|
||||
|
||||
/* if selOnly option is enabled, if user hasn't selected any bones,
|
||||
* just go back to default behaviour to be more in line with other pose tools
|
||||
* just go back to default behavior to be more in line with other pose tools
|
||||
*/
|
||||
if (selOnly) {
|
||||
if (CTX_DATA_COUNT(C, selected_pose_bones) == 0)
|
||||
|
@ -2367,7 +2367,7 @@ void CURVE_OT_smooth_radius(wmOperatorType *ot)
|
||||
/* next == 1 -> select next */
|
||||
/* next == -1 -> select previous */
|
||||
/* cont == 1 -> select continuously */
|
||||
/* selstatus, inverts behaviour */
|
||||
/* selstatus, inverts behavior */
|
||||
static void select_adjacent_cp(ListBase *editnurb, short next, short cont, short selstatus)
|
||||
{
|
||||
Nurb *nu;
|
||||
@ -5084,7 +5084,7 @@ static int select_more_exec(bContext *C, wmOperator *UNUSED(op))
|
||||
short *selbpoints;
|
||||
|
||||
/* note that NURBS surface is a special case because we mimic */
|
||||
/* the behaviour of "select more" of mesh tools. */
|
||||
/* the behavior of "select more" of mesh tools. */
|
||||
/* The algorithm is designed to work in planar cases so it */
|
||||
/* may not be optimal always (example: end of NURBS sphere) */
|
||||
if(obedit->type==OB_SURF) {
|
||||
|
@ -580,7 +580,7 @@ static short mirror_gpf_marker (bGPDframe *gpf, Scene *scene)
|
||||
}
|
||||
}
|
||||
else {
|
||||
/* initialisation time */
|
||||
/* initialization time */
|
||||
if (initialised) {
|
||||
/* reset everything for safety */
|
||||
marker = NULL;
|
||||
|
@ -701,7 +701,7 @@ static void gp_stroke_newfrombuffer (tGPsdata *p)
|
||||
|
||||
pt= gps->points;
|
||||
|
||||
/* convert all points (normal behaviour) */
|
||||
/* convert all points (normal behavior) */
|
||||
for (i=0, ptc=gpd->sbuffer; i < gpd->sbuffer_size && ptc; i++, ptc++, pt++) {
|
||||
/* convert screen-coordinates to appropriate coordinates (and store them) */
|
||||
gp_stroke_convertcoords(p, &ptc->x, &pt->x, depth_arr ? depth_arr+i:NULL);
|
||||
|
@ -339,7 +339,7 @@ short ANIM_animdata_context_getdata(bAnimContext *ac);
|
||||
|
||||
/* ------------------------ Drawing TypeInfo -------------------------- */
|
||||
|
||||
/* flag-setting behaviour */
|
||||
/* flag-setting behavior */
|
||||
typedef enum eAnimChannels_SetFlag {
|
||||
ACHANNEL_SETFLAG_CLEAR = 0, /* turn off */
|
||||
ACHANNEL_SETFLAG_ADD, /* turn on */
|
||||
@ -358,7 +358,7 @@ typedef enum eAnimChannel_Settings {
|
||||
} eAnimChannel_Settings;
|
||||
|
||||
|
||||
/* Drawing, mouse handling, and flag setting behaviour... */
|
||||
/* Drawing, mouse handling, and flag setting behavior... */
|
||||
typedef struct bAnimChannelType {
|
||||
/* type data */
|
||||
/* name of the channel type, for debugging */
|
||||
|
@ -497,7 +497,7 @@ int uiButGetUnitType(uiBut *but);
|
||||
|
||||
/* Special Buttons
|
||||
*
|
||||
* Butons with a more specific purpose:
|
||||
* Buttons with a more specific purpose:
|
||||
* - IDPoinBut: for creating buttons that work on a pointer to an ID block.
|
||||
* - MenuBut: buttons that popup a menu (in headers usually).
|
||||
* - PulldownBut: like MenuBut, but creating a uiBlock (for compatibility).
|
||||
|
@ -3384,7 +3384,7 @@ int uiButGetUnitType(uiBut *but)
|
||||
{
|
||||
int ownUnit = (int)but->unit_type;
|
||||
|
||||
/* own unit define always takes precidence over RNA provided, allowing for overriding
|
||||
/* own unit define always takes precedence over RNA provided, allowing for overriding
|
||||
* default value provided in RNA in a few special cases (i.e. Active Keyframe in Graph Edit)
|
||||
*/
|
||||
// XXX: this doesn't allow clearing unit completely, though the same could be said for icons
|
||||
|
@ -1474,7 +1474,7 @@ static void ui_textedit_set_cursor_select(uiBut *but, uiHandleButtonData *data,
|
||||
}
|
||||
|
||||
/* this is used for both utf8 and ascii, its meant to be used for single keys,
|
||||
* notie the buffer is either copied or not, so its not suitable for pasting in
|
||||
* notice the buffer is either copied or not, so its not suitable for pasting in
|
||||
* - campbell */
|
||||
static int ui_textedit_type_buf(uiBut *but, uiHandleButtonData *data,
|
||||
const char *utf8_buf, int utf8_buf_len)
|
||||
@ -3034,7 +3034,7 @@ static int ui_do_but_BLOCK(bContext *C, uiBut *but, uiHandleButtonData *data, wm
|
||||
ui_apply_button(C, but->block, but, data, 1);
|
||||
|
||||
/* button's state need to be changed to EXIT so moving mouse away from this mouse wouldn't lead
|
||||
* to cancel changes made to this button, but shanging state to EXIT also makes no button active for
|
||||
* to cancel changes made to this button, but changing state to EXIT also makes no button active for
|
||||
* a while which leads to triggering operator when doing fast scrolling mouse wheel.
|
||||
* using post activate stuff from button allows to make button be active again after checking for all
|
||||
* all that mouse leave and cancel stuff, so wuick scrool wouldnt't be an issue anumore.
|
||||
|
@ -157,7 +157,7 @@ static void view2d_masks(View2D *v2d)
|
||||
|
||||
/* Refresh and Validation */
|
||||
|
||||
/* Initialise all relevant View2D data (including view rects if first time) and/or refresh mask sizes after view resize
|
||||
/* Initialize all relevant View2D data (including view rects if first time) and/or refresh mask sizes after view resize
|
||||
* - for some of these presets, it is expected that the region will have defined some
|
||||
* additional settings necessary for the customisation of the 2D viewport to its requirements
|
||||
* - this function should only be called from region init() callbacks, where it is expected that
|
||||
@ -177,7 +177,7 @@ void UI_view2d_region_reinit(View2D *v2d, short type, int winx, int winy)
|
||||
|
||||
/* see eView2D_CommonViewTypes in UI_view2d.h for available view presets */
|
||||
switch (type) {
|
||||
/* 'standard view' - optimum setup for 'standard' view behaviour,
|
||||
/* 'standard view' - optimum setup for 'standard' view behavior,
|
||||
* that should be used new views as basis for their
|
||||
* own unique View2D settings, which should be used instead of this in most cases...
|
||||
*/
|
||||
@ -588,7 +588,7 @@ void UI_view2d_curRect_validate_resize(View2D *v2d, int resize)
|
||||
*
|
||||
* So, resolution is to just shift view by the gap between the extremities.
|
||||
* We favour moving the 'minimum' across, as that's origin for most things
|
||||
* (XXX - in the past, max was favoured... if there are bugs, swap!)
|
||||
* (XXX - in the past, max was favored... if there are bugs, swap!)
|
||||
*/
|
||||
if ((cur->xmin < tot->xmin) && (cur->xmax > tot->xmax)) {
|
||||
/* outside boundaries on both sides, so take middle-point of tot, and place in balanced way */
|
||||
@ -980,7 +980,7 @@ void UI_view2d_view_ortho(View2D *v2d)
|
||||
rctf curmasked;
|
||||
float xofs, yofs;
|
||||
|
||||
/* pixel offsets (-0.375f) are needed to get 1:1 correspondance with pixels for smooth UI drawing,
|
||||
/* pixel offsets (-0.375f) are needed to get 1:1 correspondence with pixels for smooth UI drawing,
|
||||
* but only applied where requsted
|
||||
*/
|
||||
/* XXX brecht: instead of zero at least use a tiny offset, otherwise
|
||||
@ -1019,7 +1019,7 @@ void UI_view2d_view_orthoSpecial(ARegion *ar, View2D *v2d, short xaxis)
|
||||
rctf curmasked;
|
||||
float xofs, yofs;
|
||||
|
||||
/* pixel offsets (-0.375f) are needed to get 1:1 correspondance with pixels for smooth UI drawing,
|
||||
/* pixel offsets (-0.375f) are needed to get 1:1 correspondence with pixels for smooth UI drawing,
|
||||
* but only applied where requsted
|
||||
*/
|
||||
/* XXX temp (ton) */
|
||||
|
@ -1678,7 +1678,7 @@ static void remerge_faces(knifetool_opdata *kcd)
|
||||
}
|
||||
}
|
||||
}
|
||||
/* BMESH_TODO, check if the code above validates the indicies */
|
||||
/* BMESH_TODO, check if the code above validates the indices */
|
||||
/* bm->elem_index_dirty &= ~BM_FACE; */
|
||||
bm->elem_index_dirty |= BM_FACE;
|
||||
|
||||
@ -1721,7 +1721,7 @@ static void knifenet_fill_faces(knifetool_opdata *kcd)
|
||||
BMO_elem_flag_enable(bm, e, BOUNDARY);
|
||||
}
|
||||
|
||||
/* turn knife verts into real verts, as necassary */
|
||||
/* turn knife verts into real verts, as necessary */
|
||||
BLI_mempool_iternew(kcd->kverts, &iter);
|
||||
for (kfv = BLI_mempool_iterstep(&iter); kfv; kfv = BLI_mempool_iterstep(&iter)) {
|
||||
if (!kfv->v) {
|
||||
|
@ -100,7 +100,7 @@ static void delete_customdata_layer(bContext *C, Object *ob, CustomDataLayer *la
|
||||
layer data pointer to find where the active layer has ended up.
|
||||
|
||||
|
||||
this is necassary because the deletion functions only support deleting the active
|
||||
this is necessary because the deletion functions only support deleting the active
|
||||
layer. */
|
||||
actlayerdata = data->layers[CustomData_get_active_layer_index(data, type)].data;
|
||||
rndlayerdata = data->layers[CustomData_get_render_layer_index(data, type)].data;
|
||||
|
@ -478,7 +478,7 @@ static int modifier_apply_shape(ReportList *reports, Scene *scene, Object *ob, M
|
||||
key= me->key= add_key((ID *)me);
|
||||
key->type= KEY_RELATIVE;
|
||||
/* if that was the first key block added, then it was the basis.
|
||||
* Initialise it with the mesh, and add another for the modifier */
|
||||
* Initialize it with the mesh, and add another for the modifier */
|
||||
kb= add_keyblock(key, NULL);
|
||||
mesh_to_key(me, kb);
|
||||
}
|
||||
|
@ -544,7 +544,7 @@ int ED_object_parent_set(ReportList *reports, Main *bmain, Scene *scene, Object
|
||||
bAction *act = verify_adt_action(&cu->id, 1);
|
||||
FCurve *fcu = verify_fcurve(act, NULL, "eval_time", 0, 1);
|
||||
|
||||
/* setup dummy 'generator' modifier here to get 1-1 correspondance still working */
|
||||
/* setup dummy 'generator' modifier here to get 1-1 correspondence still working */
|
||||
if (!fcu->bezt && !fcu->fpt && !fcu->modifiers.first)
|
||||
add_fmodifier(&fcu->modifiers, FMODIFIER_TYPE_GENERATOR);
|
||||
}
|
||||
|
@ -769,7 +769,7 @@ static int* getSurroundingVerts(Mesh *me, int vert, int *count)
|
||||
MLoop *ml = &me->mloop[mp->loopstart];
|
||||
while(j--) {
|
||||
/* XXX This assume a vert can only be once in a poly, even though
|
||||
* it seems logical to me, not totaly sure of that. */
|
||||
* it seems logical to me, not totally sure of that. */
|
||||
if (ml->v == vert) {
|
||||
int a, b, k;
|
||||
if(j == first_l) {
|
||||
@ -1604,7 +1604,7 @@ void ED_vgroup_mirror(Object *ob, const short mirror_weights, const short flip_v
|
||||
}
|
||||
|
||||
/* unlike editmesh we know that by only looping over the first hald of
|
||||
* the 'u' indicies it will cover all points except the middle which is
|
||||
* the 'u' indices it will cover all points except the middle which is
|
||||
* ok in this case */
|
||||
pntsu_half= lt->pntsu / 2;
|
||||
|
||||
@ -2644,7 +2644,7 @@ static int vertex_group_copy_to_selected_exec(bContext *C, wmOperator *op)
|
||||
|
||||
if((change == 0 && fail == 0) || fail) {
|
||||
BKE_reportf(op->reports, RPT_ERROR,
|
||||
"Copy to VGroups to Selected warning done %d, failed %d, object data must have matching indicies",
|
||||
"Copy to VGroups to Selected warning done %d, failed %d, object data must have matching indices",
|
||||
change, fail);
|
||||
}
|
||||
|
||||
@ -2795,7 +2795,7 @@ static int vgroup_do_remap(Object *ob, char *name_array, wmOperator *op)
|
||||
|
||||
ED_vgroup_give_array(ob->data, &dvert, &dvert_tot);
|
||||
|
||||
/*create as necassary*/
|
||||
/*create as necessary*/
|
||||
while(dvert && dvert_tot--) {
|
||||
if(dvert->totweight)
|
||||
defvert_remap(dvert, sort_map, defbase_tot);
|
||||
|
@ -48,7 +48,6 @@
|
||||
#include "RNA_define.h"
|
||||
#include "RNA_enum_types.h"
|
||||
|
||||
/* Platform independend time */
|
||||
#include "PIL_time.h"
|
||||
|
||||
#include "WM_types.h"
|
||||
@ -169,7 +168,7 @@ static int type_toggle_exec(bContext *C, wmOperator *op)
|
||||
return OPERATOR_CANCELLED;
|
||||
}
|
||||
|
||||
/* update dependancy */
|
||||
/* update dependency */
|
||||
DAG_id_tag_update(&cObject->id, OB_RECALC_DATA);
|
||||
WM_event_add_notifier(C, NC_OBJECT|ND_MODIFIER, cObject);
|
||||
DAG_scene_sort(CTX_data_main(C), scene);
|
||||
|
@ -952,7 +952,7 @@ static void pe_deflect_emitter(Scene *scene, Object *ob, PTCacheEdit *edit)
|
||||
}
|
||||
}
|
||||
}
|
||||
/* force set distances between neighbouring keys */
|
||||
/* force set distances between neighboring keys */
|
||||
static void PE_apply_lengths(Scene *scene, PTCacheEdit *edit)
|
||||
{
|
||||
|
||||
@ -977,7 +977,7 @@ static void PE_apply_lengths(Scene *scene, PTCacheEdit *edit)
|
||||
}
|
||||
}
|
||||
}
|
||||
/* try to find a nice solution to keep distances between neighbouring keys */
|
||||
/* try to find a nice solution to keep distances between neighboring keys */
|
||||
static void pe_iterate_lengths(Scene *scene, PTCacheEdit *edit)
|
||||
{
|
||||
ParticleEditSettings *pset=PE_settings(scene);
|
||||
@ -2196,7 +2196,7 @@ static void remove_tagged_keys(Object *ob, ParticleSystem *psys)
|
||||
|
||||
/************************ subdivide opertor *********************/
|
||||
|
||||
/* works like normal edit mode subdivide, inserts keys between neighbouring selected keys */
|
||||
/* works like normal edit mode subdivide, inserts keys between neighboring selected keys */
|
||||
static void subdivide_particle(PEData *data, int pa_index)
|
||||
{
|
||||
PTCacheEdit *edit= data->edit;
|
||||
|
@ -119,7 +119,7 @@ void image_buffer_rect_update(Scene *scene, RenderResult *rr, ImBuf *ibuf, volat
|
||||
|
||||
if(xmax < 1 || ymax < 1) return;
|
||||
|
||||
/* find current float rect for display, first case is after composit... still weak */
|
||||
/* find current float rect for display, first case is after composite... still weak */
|
||||
if(rr->rectf)
|
||||
rectf= rr->rectf;
|
||||
else {
|
||||
|
@ -1850,9 +1850,11 @@ static int project_bucket_isect_circle(const float cent[2], const float radius_s
|
||||
|
||||
/* Note for rect_to_uvspace_ortho() and rect_to_uvspace_persp()
|
||||
* in ortho view this function gives good results when bucket_bounds are outside the triangle
|
||||
* however in some cases, perspective view will mess up with faces that have minimal screenspace area (viewed from the side)
|
||||
* however in some cases, perspective view will mess up with faces that have minimal screenspace area
|
||||
* (viewed from the side)
|
||||
*
|
||||
* for this reason its not relyable in this case so we'll use the Simple Barycentric' funcs that only account for points inside the triangle.
|
||||
* for this reason its not reliable in this case so we'll use the Simple Barycentric'
|
||||
* funcs that only account for points inside the triangle.
|
||||
* however switching back to this for ortho is always an option */
|
||||
|
||||
static void rect_to_uvspace_ortho(
|
||||
@ -2434,7 +2436,7 @@ static void project_paint_face_init(const ProjPaintState *ps, const int thread_i
|
||||
if (is_ortho) screen_px_from_ortho(uv, v1coSS, v2coSS, v3coSS, uv1co, uv2co, uv3co, pixelScreenCo, w);
|
||||
else screen_px_from_persp(uv, v1coSS, v2coSS, v3coSS, uv1co, uv2co, uv3co, pixelScreenCo, w);
|
||||
|
||||
/* a pitty we need to get the worldspace pixel location here */
|
||||
/* a pity we need to get the worldspace pixel location here */
|
||||
if(do_clip) {
|
||||
interp_v3_v3v3v3(wco, ps->dm_mvert[ (*(&mf->v1 + i1)) ].co, ps->dm_mvert[ (*(&mf->v1 + i2)) ].co, ps->dm_mvert[ (*(&mf->v1 + i3)) ].co, w);
|
||||
if (ED_view3d_clipping_test(ps->rv3d, wco, TRUE)) {
|
||||
@ -2655,7 +2657,7 @@ static void project_paint_face_init(const ProjPaintState *ps, const int thread_i
|
||||
#endif
|
||||
}
|
||||
|
||||
/* a pitty we need to get the worldspace pixel location here */
|
||||
/* a pity we need to get the worldspace pixel location here */
|
||||
if(do_clip) {
|
||||
if (side) interp_v3_v3v3v3(wco, ps->dm_mvert[mf->v1].co, ps->dm_mvert[mf->v3].co, ps->dm_mvert[mf->v4].co, w);
|
||||
else interp_v3_v3v3v3(wco, ps->dm_mvert[mf->v1].co, ps->dm_mvert[mf->v2].co, ps->dm_mvert[mf->v3].co, w);
|
||||
@ -2731,7 +2733,7 @@ static void project_bucket_bounds(const ProjPaintState *ps, const int bucket_x,
|
||||
|
||||
/* Fill this bucket with pixels from the faces that intersect it.
|
||||
*
|
||||
* have bucket_bounds as an argument so we don;t need to give bucket_x/y the rect function needs */
|
||||
* have bucket_bounds as an argument so we don't need to give bucket_x/y the rect function needs */
|
||||
static void project_bucket_init(const ProjPaintState *ps, const int thread_index, const int bucket_index, rctf *bucket_bounds)
|
||||
{
|
||||
LinkNode *node;
|
||||
|
@ -146,7 +146,7 @@ static int actkeys_deselectall_exec(bContext *C, wmOperator *op)
|
||||
if (ANIM_animdata_get_context(C, &ac) == 0)
|
||||
return OPERATOR_CANCELLED;
|
||||
|
||||
/* 'standard' behaviour - check if selected, then apply relevant selection */
|
||||
/* 'standard' behavior - check if selected, then apply relevant selection */
|
||||
if (RNA_boolean_get(op->ptr, "invert"))
|
||||
deselect_action_keys(&ac, 0, SELECT_INVERT);
|
||||
else
|
||||
@ -296,7 +296,7 @@ static int actkeys_borderselect_exec(bContext *C, wmOperator *op)
|
||||
if (RNA_boolean_get(op->ptr, "axis_range")) {
|
||||
/* mode depends on which axis of the range is larger to determine which axis to use
|
||||
* - checking this in region-space is fine, as it's fundamentally still going to be a different rect size
|
||||
* - the frame-range select option is favoured over the channel one (x over y), as frame-range one is often
|
||||
* - the frame-range select option is favored over the channel one (x over y), as frame-range one is often
|
||||
* used for tweaking timing when "blocking", while channels is not that useful...
|
||||
*/
|
||||
if ((rect.xmax - rect.xmin) >= (rect.ymax - rect.ymin))
|
||||
|
@ -850,7 +850,7 @@ void graph_draw_curves (bAnimContext *ac, SpaceIpo *sipo, ARegion *ar, View2DGri
|
||||
/* draw curve:
|
||||
* - curve line may be result of one or more destructive modifiers or just the raw data,
|
||||
* so we need to check which method should be used
|
||||
* - controls from active modifier take precidence over keyframes
|
||||
* - controls from active modifier take precedence over keyframes
|
||||
* (XXX! editing tools need to take this into account!)
|
||||
*/
|
||||
|
||||
|
@ -154,7 +154,7 @@ static int graphkeys_deselectall_exec(bContext *C, wmOperator *op)
|
||||
if (ANIM_animdata_get_context(C, &ac) == 0)
|
||||
return OPERATOR_CANCELLED;
|
||||
|
||||
/* 'standard' behaviour - check if selected, then apply relevant selection */
|
||||
/* 'standard' behavior - check if selected, then apply relevant selection */
|
||||
if (RNA_boolean_get(op->ptr, "invert"))
|
||||
deselect_graph_keys(&ac, 0, SELECT_INVERT, TRUE);
|
||||
else
|
||||
@ -325,7 +325,7 @@ static int graphkeys_borderselect_exec(bContext *C, wmOperator *op)
|
||||
if (RNA_boolean_get(op->ptr, "axis_range")) {
|
||||
/* mode depends on which axis of the range is larger to determine which axis to use
|
||||
* - checking this in region-space is fine, as it's fundamentally still going to be a different rect size
|
||||
* - the frame-range select option is favoured over the channel one (x over y), as frame-range one is often
|
||||
* - the frame-range select option is favored over the channel one (x over y), as frame-range one is often
|
||||
* used for tweaking timing when "blocking", while channels is not that useful...
|
||||
*/
|
||||
if ((rect.xmax - rect.xmin) >= (rect.ymax - rect.ymin))
|
||||
|
@ -172,7 +172,7 @@ static void nla_strip_get_color_inside (AnimData *adt, NlaStrip *strip, float co
|
||||
color[2]= 0.86f;
|
||||
}
|
||||
else {
|
||||
/* normal, unselected strip - use (hardly noticable) blue tinge */
|
||||
/* normal, unselected strip - use (hardly noticeable) blue tinge */
|
||||
// FIXME: hardcoded temp-hack colors
|
||||
color[0]= 0.11f;
|
||||
color[1]= 0.15f;
|
||||
@ -190,7 +190,7 @@ static void nla_strip_get_color_inside (AnimData *adt, NlaStrip *strip, float co
|
||||
color[2]= 0.59f;
|
||||
}
|
||||
else {
|
||||
/* normal, unselected strip - use (hardly noticable) dark purple tinge */
|
||||
/* normal, unselected strip - use (hardly noticeable) dark purple tinge */
|
||||
// FIXME: hardcoded temp-hack colors
|
||||
color[0]= 0.20f;
|
||||
color[1]= 0.15f;
|
||||
@ -207,7 +207,7 @@ static void nla_strip_get_color_inside (AnimData *adt, NlaStrip *strip, float co
|
||||
color[2]= 0.48f;
|
||||
}
|
||||
else {
|
||||
/* normal, unselected strip - use (hardly noticable) teal tinge */
|
||||
/* normal, unselected strip - use (hardly noticeable) teal tinge */
|
||||
// FIXME: hardcoded temp-hack colors
|
||||
color[0]= 0.17f;
|
||||
color[1]= 0.24f;
|
||||
@ -813,7 +813,7 @@ static void draw_nla_channel_list_gl (bAnimContext *ac, ListBase *anim_data, Vie
|
||||
/* only on top two corners, to show that this channel sits on top of the preceding ones */
|
||||
uiSetRoundBox(UI_CNR_TOP_LEFT | UI_CNR_TOP_RIGHT);
|
||||
|
||||
/* draw slightly shifted up vertically to look like it has more separtion from other channels,
|
||||
/* draw slightly shifted up vertically to look like it has more separation from other channels,
|
||||
* but we then need to slightly shorten it so that it doesn't look like it overlaps
|
||||
*/
|
||||
uiDrawBox(GL_POLYGON, x+offset, yminc+NLACHANNEL_SKIP, (float)v2d->cur.xmax, ymaxc+NLACHANNEL_SKIP-1, 8);
|
||||
|
@ -171,7 +171,7 @@ static int nlaedit_deselectall_exec(bContext *C, wmOperator *op)
|
||||
if (ANIM_animdata_get_context(C, &ac) == 0)
|
||||
return OPERATOR_CANCELLED;
|
||||
|
||||
/* 'standard' behaviour - check if selected, then apply relevant selection */
|
||||
/* 'standard' behavior - check if selected, then apply relevant selection */
|
||||
if (RNA_boolean_get(op->ptr, "invert"))
|
||||
deselect_nla_strips(&ac, DESELECT_STRIPS_NOTEST, SELECT_INVERT);
|
||||
else
|
||||
@ -308,7 +308,7 @@ static int nlaedit_borderselect_exec(bContext *C, wmOperator *op)
|
||||
if (RNA_boolean_get(op->ptr, "axis_range")) {
|
||||
/* mode depends on which axis of the range is larger to determine which axis to use
|
||||
* - checking this in region-space is fine, as it's fundamentally still going to be a different rect size
|
||||
* - the frame-range select option is favoured over the channel one (x over y), as frame-range one is often
|
||||
* - the frame-range select option is favored over the channel one (x over y), as frame-range one is often
|
||||
* used for tweaking timing when "blocking", while channels is not that useful...
|
||||
*/
|
||||
if ((rect.xmax - rect.xmin) >= (rect.ymax - rect.ymin))
|
||||
|
@ -339,7 +339,7 @@ static void node_buttons_area_draw(const bContext *C, ARegion *ar)
|
||||
ED_region_panels(C, ar, 1, NULL, -1);
|
||||
}
|
||||
|
||||
/* Initialise main area, setting handlers. */
|
||||
/* Initialize main area, setting handlers. */
|
||||
static void node_main_area_init(wmWindowManager *wm, ARegion *ar)
|
||||
{
|
||||
wmKeyMap *keymap;
|
||||
|
@ -92,7 +92,7 @@ static void sequencer_generic_props__internal(wmOperatorType *ot, int flag)
|
||||
RNA_def_int(ot->srna, "frame_start", 0, INT_MIN, INT_MAX, "Start Frame", "Start frame of the sequence strip", INT_MIN, INT_MAX);
|
||||
|
||||
if(flag & SEQPROP_ENDFRAME)
|
||||
RNA_def_int(ot->srna, "frame_end", 0, INT_MIN, INT_MAX, "End Frame", "End frame for the color strip", INT_MIN, INT_MAX); /* not useual since most strips have a fixed length */
|
||||
RNA_def_int(ot->srna, "frame_end", 0, INT_MIN, INT_MAX, "End Frame", "End frame for the color strip", INT_MIN, INT_MAX); /* not usual since most strips have a fixed length */
|
||||
|
||||
RNA_def_int(ot->srna, "channel", 1, 1, MAXSEQ, "Channel", "Channel to place this strip into", 1, MAXSEQ);
|
||||
|
||||
|
@ -179,7 +179,7 @@ void draw_motion_path_instance(Scene *scene,
|
||||
glPointSize(1.0);
|
||||
|
||||
/* draw little black point at each frame
|
||||
* NOTE: this is not really visible/noticable
|
||||
* NOTE: this is not really visible/noticeable
|
||||
*/
|
||||
glBegin(GL_POINTS);
|
||||
for (i=0, mpv=mpv_start; i < len; i++, mpv++)
|
||||
|
@ -1482,7 +1482,7 @@ static void draw_limit_line(float sta, float end, unsigned int col)
|
||||
|
||||
|
||||
/* yafray: draw camera focus point (cross, similar to aqsis code in tuhopuu) */
|
||||
/* qdn: now also enabled for Blender to set focus point for defocus composit node */
|
||||
/* qdn: now also enabled for Blender to set focus point for defocus composite node */
|
||||
static void draw_focus_cross(float dist, float size)
|
||||
{
|
||||
glBegin(GL_LINES);
|
||||
@ -1822,7 +1822,7 @@ static void drawcamera(Scene *scene, View3D *v3d, RegionView3D *rv3d, Base *base
|
||||
|
||||
if (cam->flag & CAM_SHOWLIMITS) {
|
||||
draw_limit_line(cam->clipsta, cam->clipend, 0x77FFFF);
|
||||
/* qdn: was yafray only, now also enabled for Blender to be used with defocus composit node */
|
||||
/* qdn: was yafray only, now also enabled for Blender to be used with defocus composite node */
|
||||
draw_focus_cross(object_camera_dof_distance(ob), cam->drawsize);
|
||||
}
|
||||
|
||||
@ -2018,7 +2018,7 @@ static void drawlattice(Scene *scene, View3D *v3d, Object *ob)
|
||||
/* Note! - foreach funcs should be called while drawing or directly after
|
||||
* if not, ED_view3d_init_mats_rv3d() can be used for selection tools
|
||||
* but would not give correct results with dupli's for eg. which dont
|
||||
* use the object matrix in the useual way */
|
||||
* use the object matrix in the usual way */
|
||||
static void mesh_foreachScreenVert__mapFunc(void *userData, int index, float *co, float *UNUSED(no_f), short *UNUSED(no_s))
|
||||
{
|
||||
foreachScreenVert_userData *data = userData;
|
||||
|
@ -1078,7 +1078,7 @@ static void drawviewborder(Scene *scene, ARegion *ar, View3D *v3d)
|
||||
/* note: quite un-scientific but without this bit extra
|
||||
* 0.0001 on the lower left the 2D border sometimes
|
||||
* obscures the 3D camera border */
|
||||
/* note: with VIEW3D_CAMERA_BORDER_HACK defined this error isn't noticable
|
||||
/* note: with VIEW3D_CAMERA_BORDER_HACK defined this error isn't noticeable
|
||||
* but keep it here incase we need to remove the workaround */
|
||||
x1i= (int)(x1 - 1.0001f);
|
||||
y1i= (int)(y1 - 1.0001f);
|
||||
|
@ -199,7 +199,7 @@ extern const char *view3d_context_dir[]; /* doc access */
|
||||
/* draw_volume.c */
|
||||
void draw_volume(struct ARegion *ar, struct GPUTexture *tex, float *min, float *max, int res[3], float dx, struct GPUTexture *tex_shadow);
|
||||
|
||||
/* workaround for trivial but noticable camera bug caused by imprecision
|
||||
/* workaround for trivial but noticeable camera bug caused by imprecision
|
||||
* between view border calculation in 2D/3D space, workaround for bug [#28037].
|
||||
* without this deifne we get the old behavior which is to try and align them
|
||||
* both which _mostly_ works fine, but when the camera moves beyond ~1000 in
|
||||
|
@ -285,7 +285,7 @@ static void make_trans_verts(Object *obedit, float *min, float *max, int mode)
|
||||
BM_ITER(eve, &iter, bm, BM_VERTS_OF_MESH, NULL)
|
||||
if (BM_elem_index_get(eve)) tottrans++;
|
||||
}
|
||||
/* for any of the 3 loops above which all dirty the indicies */
|
||||
/* for any of the 3 loops above which all dirty the indices */
|
||||
bm->elem_index_dirty |= BM_VERT;
|
||||
|
||||
/* and now make transverts */
|
||||
|
@ -5355,7 +5355,7 @@ static void doAnimEdit_SnapFrame(TransInfo *t, TransData *td, TransData2D *td2d,
|
||||
#if 0 /* 'doTime' disabled for now */
|
||||
|
||||
const Scene *scene= t->scene;
|
||||
const short doTime= 0; //getAnimEdit_DrawTime(t); // NOTE: this works, but may be confusing behaviour given the option's label, hence disabled
|
||||
const short doTime= 0; //getAnimEdit_DrawTime(t); // NOTE: this works, but may be confusing behavior given the option's label, hence disabled
|
||||
const double secf= FPS;
|
||||
#endif
|
||||
double val;
|
||||
|
@ -3055,7 +3055,7 @@ static TransData *ActionFCurveToTransData(TransData *td, TransData2D **td2dv, FC
|
||||
if (FrameOnMouseSide(side, bezt->vec[1][0], cfra)) {
|
||||
TimeToTransData(td, bezt->vec[1], adt);
|
||||
|
||||
/*set flags to move handles as necassary*/
|
||||
/*set flags to move handles as necessary*/
|
||||
td->flag |= TD_MOVEHANDLE1|TD_MOVEHANDLE2;
|
||||
td2d->h1 = bezt->vec[0];
|
||||
td2d->h2 = bezt->vec[2];
|
||||
@ -3274,7 +3274,7 @@ static void createTransActionData(bContext *C, TransInfo *t)
|
||||
|
||||
/* ********************* GRAPH EDITOR ************************* */
|
||||
|
||||
/* Helper function for createTransGraphEditData, which is reponsible for associating
|
||||
/* Helper function for createTransGraphEditData, which is responsible for associating
|
||||
* source data with transform data
|
||||
*/
|
||||
static void bezt_to_transdata (TransData *td, TransData2D *td2d, AnimData *adt, BezTriple *bezt,
|
||||
@ -4356,7 +4356,7 @@ static void ObjectToTransData(TransInfo *t, TransData *td, Object *ob)
|
||||
|
||||
td->con= ob->constraints.first;
|
||||
|
||||
/* hack: tempolarily disable tracking and/or constraints when getting
|
||||
/* hack: temporarily disable tracking and/or constraints when getting
|
||||
* object matrix, if tracking is on, or if constraints don't need
|
||||
* inverse correction to stop it from screwing up space conversion
|
||||
* matrix later
|
||||
|
@ -500,7 +500,7 @@ static void recalcData_nla(TransInfo *t)
|
||||
continue;
|
||||
}
|
||||
|
||||
/* firstly, check if the proposed transform locations would overlap with any neighbouring strips
|
||||
/* firstly, check if the proposed transform locations would overlap with any neighboring strips
|
||||
* (barring transitions) which are absolute barriers since they are not being moved
|
||||
*
|
||||
* this is done as a iterative procedure (done 5 times max for now)
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user