forked from bartvdbraak/blender
code cleanup: spelling
This commit is contained in:
Campbell Barton
parent
1f96470b5d
commit
32cf7fcdb1
@ -486,7 +486,7 @@ VertexFaces(
|
||||
BSP_MEdge &e = edges[*e_it];
|
||||
|
||||
// iterate through the faces of this edge - push unselected
|
||||
// edges to ouput and then select the edge
|
||||
// edges to output and then select the edge
|
||||
|
||||
vector<BSP_FaceInd>::const_iterator e_faces_end = e.m_faces.end();
|
||||
vector<BSP_FaceInd>::iterator e_faces_it = e.m_faces.begin();
|
||||
|
||||
@ -22,7 +22,7 @@ CCL_NAMESPACE_BEGIN
|
||||
|
||||
__device void differential_transfer(differential3 *dP_, const differential3 dP, float3 D, const differential3 dD, float3 Ng, float t)
|
||||
{
|
||||
/* ray differential transfer through homogenous medium, to
|
||||
/* ray differential transfer through homogeneous medium, to
|
||||
* compute dPdx/dy at a shading point from the incoming ray */
|
||||
|
||||
float3 tmp = D/dot(D, Ng);
|
||||
|
||||
@ -54,7 +54,7 @@ Octree::Octree(ModelReader *mr,
|
||||
After playing around with this option, the only case I could
|
||||
find where this option gives different results is on
|
||||
relatively thin corners. Sometimes along these corners two
|
||||
vertices from seperate sides will be placed in the same
|
||||
vertices from separate sides will be placed in the same
|
||||
position, so hole gets filled with a 5-sided face, where two
|
||||
of those vertices are in the same 3D location. If
|
||||
`use_manifold' is disabled, then the modifier doesn't
|
||||
|
||||
@ -40,7 +40,7 @@ public:
|
||||
{
|
||||
q_nr += m_qrange.start;
|
||||
project(m_scene->m_Wq, Range(q_nr, ndof), m_qrange).setZero();
|
||||
// update the ouput vector so that the movement of this joint will be
|
||||
// update the ouput vector so that the movement of this joint will be
|
||||
// taken into account and we can put the joint back in its initial position
|
||||
// which means that the jacobian doesn't need to be changed
|
||||
for (unsigned int i=0 ;i<ndof ; ++i, ++q_nr) {
|
||||
|
||||
@ -461,7 +461,7 @@ static int rast_scan_feather(struct r_fill_context *ctx,
|
||||
//unsigned int gradientFillOffset;
|
||||
float t;
|
||||
float ud; // ud = unscaled edge distance
|
||||
float dmin; // dmin = minimun edge distance
|
||||
float dmin; // dmin = minimum edge distance
|
||||
float odist; // odist = current outer edge distance
|
||||
float idist; // idist = current inner edge distance
|
||||
float dx; // dx = X-delta (used for distance proportion calculation)
|
||||
@ -643,7 +643,7 @@ static int rast_scan_feather(struct r_fill_context *ctx,
|
||||
/*
|
||||
* Note once again that since we are using reciprocals of distance values our
|
||||
* proportion is already the correct intensity, and does not need to be
|
||||
* subracted from 1.0 like it would have if we used real distances.
|
||||
* subtracted from 1.0 like it would have if we used real distances.
|
||||
*/
|
||||
#else
|
||||
clup[0]=t;
|
||||
|
||||
@ -105,7 +105,7 @@ class FLUID_3D
|
||||
float* _xForce;
|
||||
float* _yForce;
|
||||
float* _zForce;
|
||||
unsigned char* _obstacles; /* only used (usefull) for static obstacles like domain boundaries */
|
||||
unsigned char* _obstacles; /* only used (useful) for static obstacles like domain boundaries */
|
||||
unsigned char* _obstaclesAnim;
|
||||
|
||||
// Required for proper threading:
|
||||
|
||||
@ -1588,7 +1588,7 @@ static int cu_isectLL(const float v1[3], const float v2[3], const float v3[3], c
|
||||
float *labda, float *mu, float vec[3])
|
||||
{
|
||||
/* return:
|
||||
* -1: colliniar
|
||||
* -1: collinear
|
||||
* 0: no intersection of segments
|
||||
* 1: exact intersection of segments
|
||||
* 2: cross-intersection of segments
|
||||
|
||||
@ -1298,7 +1298,7 @@ float evaluate_time_fmodifiers(ListBase *modifiers, FCurve *fcu, float cvalue, f
|
||||
return evaltime;
|
||||
}
|
||||
|
||||
/* Evalautes the given set of F-Curve Modifiers using the given data
|
||||
/* Evaluates the given set of F-Curve Modifiers using the given data
|
||||
* Should only be called after evaluate_time_fmodifiers() has been called...
|
||||
*/
|
||||
void evaluate_value_fmodifiers(ListBase *modifiers, FCurve *fcu, float *cvalue, float evaltime)
|
||||
|
||||
@ -345,7 +345,7 @@ void group_handle_recalc_and_update(Scene *scene, Object *UNUSED(parent), Group
|
||||
|
||||
#if 0 /* warning, isn't clearing the recalc flag on the object which causes it to run all the time,
|
||||
* not just on frame change.
|
||||
* This isn't working because the animation data is only re-evalyated on frame change so commenting for now
|
||||
* This isn't working because the animation data is only re-evaluated on frame change so commenting for now
|
||||
* but when its enabled at some point it will need to be changed so as not to update so much - campbell */
|
||||
|
||||
/* if animated group... */
|
||||
|
||||
@ -185,7 +185,7 @@ DO_INLINE void print_lfvector(float (*fLongVector)[3], unsigned int verts)
|
||||
/* create long vector */
|
||||
DO_INLINE lfVector *create_lfvector(unsigned int verts)
|
||||
{
|
||||
/* TODO: check if memory allocation was successfull */
|
||||
/* TODO: check if memory allocation was successful */
|
||||
return (lfVector *)MEM_callocN(verts * sizeof(lfVector), "cloth_implicit_alloc_vector");
|
||||
// return (lfVector *)cloth_aligned_malloc(&MEMORY_BASE, verts * sizeof(lfVector));
|
||||
}
|
||||
@ -513,7 +513,7 @@ static void print_bfmatrix(fmatrix3x3 *m3)
|
||||
/* create big matrix */
|
||||
DO_INLINE fmatrix3x3 *create_bfmatrix(unsigned int verts, unsigned int springs)
|
||||
{
|
||||
// TODO: check if memory allocation was successfull */
|
||||
// TODO: check if memory allocation was successful */
|
||||
fmatrix3x3 *temp = (fmatrix3x3 *)MEM_callocN(sizeof(fmatrix3x3) * (verts + springs), "cloth_implicit_alloc_matrix");
|
||||
temp[0].vcount = verts;
|
||||
temp[0].scount = springs;
|
||||
|
||||
@ -134,7 +134,6 @@ void BKE_maskrasterize_handle_free(MaskRasterHandle *mr_handle)
|
||||
unsigned int i;
|
||||
MaskRasterLayer *layer = mr_handle->layers;
|
||||
|
||||
/* raycast vars */
|
||||
for (i = 0; i < layers_tot; i++, layer++) {
|
||||
|
||||
if (layer->face_array) {
|
||||
@ -225,7 +224,7 @@ void maskrasterize_spline_differentiate_point_outset(float (*diff_feather_points
|
||||
}
|
||||
}
|
||||
|
||||
/* this function is not exact, sometimes it retuns false positives,
|
||||
/* this function is not exact, sometimes it returns false positives,
|
||||
* the main point of it is to clear out _almost_ all bucket/face non-intersections,
|
||||
* returning TRUE in corner cases is ok but missing an intersection is NOT.
|
||||
*
|
||||
|
||||
@ -2307,7 +2307,7 @@ void BKE_mball_polygonize(Scene *scene, Object *ob, ListBase *dispbase)
|
||||
metaball_tree = NULL;
|
||||
}
|
||||
|
||||
/* if scene includes more then one MetaElem, then octal tree optimalisation is used */
|
||||
/* if scene includes more then one MetaElem, then octal tree optimization is used */
|
||||
if ((totelem > 1) && (totelem <= 64)) init_metaball_octal_tree(1);
|
||||
if ((totelem > 64) && (totelem <= 128)) init_metaball_octal_tree(2);
|
||||
if ((totelem > 128) && (totelem <= 512)) init_metaball_octal_tree(3);
|
||||
|
||||
@ -2105,7 +2105,7 @@ void multires_load_old(Object *ob, Mesh *me)
|
||||
/* XXX We *must* alloc paint mask here, else we have some kind of mismatch in
|
||||
* multires_modifier_update_mdisps() (called by dm->release(dm)), which always creates the
|
||||
* reference subsurfed dm with this option, before calling multiresModifier_disp_run(),
|
||||
* which implitely expects both subsurfs from its first dm and oldGridData parameters to
|
||||
* which implicitly expects both subsurfs from its first dm and oldGridData parameters to
|
||||
* be of the same "format"! */
|
||||
dm = multires_make_derived_from_derived(orig, mmd, ob, MULTIRES_ALLOC_PAINT_MASK);
|
||||
|
||||
@ -2120,7 +2120,7 @@ void multires_load_old(Object *ob, Mesh *me)
|
||||
me->mr = NULL;
|
||||
}
|
||||
|
||||
/* If 'ob' and 'to_ob' both have multires modifiers, syncronize them
|
||||
/* If 'ob' and 'to_ob' both have multires modifiers, synchronize them
|
||||
* such that 'ob' has the same total number of levels as 'to_ob'. */
|
||||
static void multires_sync_levels(Scene *scene, Object *ob, Object *to_ob)
|
||||
{
|
||||
|
||||
@ -2320,7 +2320,7 @@ void BKE_ptcache_id_time(PTCacheID *pid, Scene *scene, float cfra, int *startfra
|
||||
* - simulation time is scaled by result of bsystem_time
|
||||
* - for offsetting time only time offset is taken into account, since
|
||||
* that's always the same and can't be animated. a timeoffset which
|
||||
* varies over time is not simpe to support.
|
||||
* varies over time is not simple to support.
|
||||
* - field and motion blur offsets are currently ignored, proper solution
|
||||
* is probably to interpolate results from two frames for that ..
|
||||
*/
|
||||
|
||||
@ -310,7 +310,7 @@ static void do_alphaunder_effect_byte(
|
||||
|
||||
/* rt = rt1 under rt2 (alpha from rt2) */
|
||||
|
||||
/* this complex optimalisation is because the
|
||||
/* this complex optimization is because the
|
||||
* 'skybuf' can be crossed in
|
||||
*/
|
||||
if (rt2[3] == 0 && fac2 == 256) *( (unsigned int *)rt) = *( (unsigned int *)rt1);
|
||||
@ -379,7 +379,7 @@ static void do_alphaunder_effect_float(float facf0, float facf1, int x, int y,
|
||||
|
||||
/* rt = rt1 under rt2 (alpha from rt2) */
|
||||
|
||||
/* this complex optimalisation is because the
|
||||
/* this complex optimization is because the
|
||||
* 'skybuf' can be crossed in
|
||||
*/
|
||||
if (rt2[3] <= 0 && fac2 >= 1.0f) {
|
||||
|
||||
@ -464,7 +464,7 @@ void seq_end(SeqIterator *iter)
|
||||
* **********************************************************************
|
||||
* build_seqar
|
||||
* *********************************************************************
|
||||
* Build a complete array of _all_ sequencies (including those
|
||||
* Build a complete array of _all_ sequences (including those
|
||||
* in metastrips!)
|
||||
* *********************************************************************
|
||||
*/
|
||||
|
||||
@ -2914,7 +2914,7 @@ static void softbody_apply_forces(Object *ob, float forcetime, int mode, float *
|
||||
aabbmin[0]=aabbmin[1]=aabbmin[2] = 1e20f;
|
||||
aabbmax[0]=aabbmax[1]=aabbmax[2] = -1e20f;
|
||||
|
||||
/* old one with homogenous masses */
|
||||
/* old one with homogeneous masses */
|
||||
/* claim a minimum mass for vertex */
|
||||
/*
|
||||
if (sb->nodemass > 0.009999f) timeovermass = forcetime/sb->nodemass;
|
||||
@ -3297,7 +3297,7 @@ static void mesh_to_softbody(Scene *scene, Object *ob)
|
||||
/* I'd like to have it .. if (sb->namedVG_Goal[0]) */
|
||||
|
||||
get_scalar_from_vertexgroup(ob, a, (short) (sb->vertgroup-1), &bp->goal);
|
||||
/* do this always, regardless successfull read from vertex group */
|
||||
/* do this always, regardless successful read from vertex group */
|
||||
/* this is where '2.5 every thing is animatable' goes wrong in the first place jow_go_for2_5 */
|
||||
/* 1st coding action to take : move this to frame level */
|
||||
/* reads: leave the bp->goal as it was read from vertex group / or default .. we will need it at per frame call */
|
||||
@ -3811,7 +3811,7 @@ static void softbody_update_positions(Object *ob, SoftBody *sb, float (*vertexCo
|
||||
* that is:
|
||||
* a precise position vector denoting the motion of the center of mass
|
||||
* give a rotation/scale matrix using averaging method, that's why estimate and not calculate
|
||||
* see: this is kind of reverse engeneering: having to states of a point cloud and recover what happend
|
||||
* see: this is kind of reverse engineering: having to states of a point cloud and recover what happend
|
||||
* our advantage here we know the identity of the vertex
|
||||
* there are others methods giving other results.
|
||||
* lloc, lrot, lscale are allowed to be NULL, just in case you don't need it.
|
||||
|
||||
@ -687,7 +687,7 @@ static void split_leafs(BVHNode **leafs_array, int *nth, int partitions, int spl
|
||||
* The reason is that we can build level N+1 from level N without any data dependencies.. thus it allows
|
||||
* to use multithread building.
|
||||
*
|
||||
* To archieve this is necessary to find how much leafs are accessible from a certain branch, BVHBuildHelper
|
||||
* To archive this is necessary to find how much leafs are accessible from a certain branch, BVHBuildHelper
|
||||
* implicit_needed_branches and implicit_leafs_index are auxiliary functions to solve that "optimal-split".
|
||||
*/
|
||||
static void non_recursive_bvh_div_nodes(BVHTree *tree, BVHNode *branches_array, BVHNode **leafs_array, int num_leafs)
|
||||
@ -748,7 +748,7 @@ static void non_recursive_bvh_div_nodes(BVHTree *tree, BVHNode *branches_array,
|
||||
parent->main_axis = split_axis / 2;
|
||||
|
||||
/* Split the childs along the split_axis, note: its not needed to sort the whole leafs array
|
||||
* Only to assure that the elements are partioned on a way that each child takes the elements
|
||||
* Only to assure that the elements are partitioned on a way that each child takes the elements
|
||||
* it would take in case the whole array was sorted.
|
||||
* Split_leafs takes care of that "sort" problem. */
|
||||
nth_positions[0] = parent_leafs_begin;
|
||||
@ -982,7 +982,7 @@ void BLI_bvhtree_update_tree(BVHTree *tree)
|
||||
{
|
||||
/* Update bottom=>top
|
||||
* TRICKY: the way we build the tree all the childs have an index greater than the parent
|
||||
* This allows us todo a bottom up update by starting on the biger numbered branch */
|
||||
* This allows us todo a bottom up update by starting on the bigger numbered branch */
|
||||
|
||||
BVHNode **root = tree->nodes + tree->totleaf;
|
||||
BVHNode **index = tree->nodes + tree->totleaf + tree->totbranch - 1;
|
||||
@ -1000,7 +1000,7 @@ float BLI_bvhtree_getepsilon(BVHTree *tree)
|
||||
/*
|
||||
* BLI_bvhtree_overlap
|
||||
*
|
||||
* overlap - is it possbile for 2 bv's to collide ? */
|
||||
* overlap - is it possible for 2 bv's to collide ? */
|
||||
static int tree_overlap(BVHNode *node1, BVHNode *node2, int start_axis, int stop_axis)
|
||||
{
|
||||
float *bv1 = node1->bv;
|
||||
|
||||
@ -423,7 +423,7 @@ static void insert_check_2(DLRBT_Tree *tree, DLRBT_Node *node)
|
||||
/* - make the grandparent red, so that we maintain alternating red/black property
|
||||
* (it must exist, so no need to check for NULL here),
|
||||
* - as the grandparent may now cause inconsistencies with the rest of the tree,
|
||||
* we must flush up the tree and perform checks/rebalancing/repainting, using the
|
||||
* we must flush up the tree and perform checks/re-balancing/re-painting, using the
|
||||
* grandparent as the node of interest
|
||||
*/
|
||||
gp->tree_col = DLRBT_RED;
|
||||
|
||||
@ -352,7 +352,7 @@ int isect_line_line_v2(const float v1[2], const float v2[2], const float v3[2],
|
||||
}
|
||||
|
||||
/* get intersection point of two 2D segments and return intersection type:
|
||||
* -1: colliniar
|
||||
* -1: collinear
|
||||
* 1: intersection
|
||||
*/
|
||||
int isect_seg_seg_v2_point(const float v1[2], const float v2[2], const float v3[2], const float v4[2], float vi[2])
|
||||
@ -410,7 +410,7 @@ int isect_seg_seg_v2_point(const float v1[2], const float v2[2], const float v3[
|
||||
}
|
||||
}
|
||||
|
||||
/* lines are colliniar */
|
||||
/* lines are collinear */
|
||||
return -1;
|
||||
}
|
||||
|
||||
@ -561,7 +561,7 @@ int isect_line_sphere_v2(const float l1[2], const float l2[2],
|
||||
}
|
||||
|
||||
/*
|
||||
* -1: colliniar
|
||||
* -1: collinear
|
||||
* 1: intersection
|
||||
*/
|
||||
static short IsectLLPt2Df(const float x0, const float y0, const float x1, const float y1,
|
||||
@ -1669,7 +1669,7 @@ static int point_in_slice(const float p[3], const float v1[3], const float l1[3]
|
||||
* a line including l1,l2 and a point not on the line
|
||||
* define a subset of R3 delimited by planes parallel to the line and orthogonal
|
||||
* to the (point --> line) distance vector,one plane on the line one on the point,
|
||||
* the room inside usually is rather small compared to R3 though still infinte
|
||||
* the room inside usually is rather small compared to R3 though still infinite
|
||||
* useful for restricting (speeding up) searches
|
||||
* e.g. all points of triangular prism are within the intersection of 3 'slices'
|
||||
* onother trivial case : cube
|
||||
@ -2843,7 +2843,7 @@ void vcloud_estimate_transform(int list_size, float (*pos)[3], float *weight, fl
|
||||
if (lloc) copy_v3_v3(lloc, accu_com);
|
||||
if (rloc) copy_v3_v3(rloc, accu_rcom);
|
||||
if (lrot || lscale) { /* caller does not want rot nor scale, strange but legal */
|
||||
/*so now do some reverse engeneering and see if we can split rotation from scale ->Polardecompose*/
|
||||
/*so now do some reverse engineering and see if we can split rotation from scale ->Polardecompose*/
|
||||
/* build 'projection' matrix */
|
||||
float m[3][3], mr[3][3], q[3][3], qi[3][3];
|
||||
float va[3], vb[3], stunt[3];
|
||||
|
||||
@ -521,7 +521,7 @@ MINLINE void cross_v3_v3v3(float r[3], const float a[3], const float b[3])
|
||||
}
|
||||
|
||||
/* Newell's Method */
|
||||
/* excuse this fairly spesific function,
|
||||
/* excuse this fairly specific function,
|
||||
* its used for polygon normals all over the place
|
||||
* could use a better name */
|
||||
MINLINE void add_newell_cross_v3_v3v3(float n[3], const float v_prev[3], const float v_curr[3])
|
||||
|
||||
@ -1552,7 +1552,7 @@ char *BLI_path_basename(char *path)
|
||||
* 0 if image filename is empty or if destination path
|
||||
* matches image path (i.e. both are the same file).
|
||||
* 2 if source is identical to destination.
|
||||
* 1 if rebase was successfull
|
||||
* 1 if rebase was successful
|
||||
* -------------------------------------------------------------
|
||||
* Hint: Trailing slash in dest_dir is optional.
|
||||
*
|
||||
|
||||
@ -255,7 +255,7 @@ static void convert_tface_mt(FileData *fd, Main *main);
|
||||
* in the case of libraray linking errors this is important!
|
||||
*
|
||||
* bit kludge but better then doubling up on prints,
|
||||
* we could alternatively have a versions of a report function which foces printing - campbell
|
||||
* we could alternatively have a versions of a report function which forces printing - campbell
|
||||
*/
|
||||
static void BKE_reportf_wrap(ReportList *reports, ReportType type, const char *format, ...)
|
||||
{
|
||||
@ -5919,7 +5919,7 @@ static void direct_link_screen(FileData *fd, bScreen *sc)
|
||||
}
|
||||
else if (sl->spacetype == SPACE_SEQ) {
|
||||
/* grease pencil data is not a direct data and can't be linked from direct_link*
|
||||
* functions, it should be linked from lib_link* funcrions instead
|
||||
* functions, it should be linked from lib_link* functions instead
|
||||
*
|
||||
* otherwise it'll lead to lost grease data on open because it'll likely be
|
||||
* read from file after all other users of grease pencil and newdataadr would
|
||||
@ -5948,7 +5948,7 @@ static void direct_link_screen(FileData *fd, bScreen *sc)
|
||||
//for (cl= sconsole->scrollback.first; cl; cl= cl->next)
|
||||
// cl->line= newdataadr(fd, cl->line);
|
||||
|
||||
/* comma expressions, (e.g. expr1, expr2, expr3) evalutate each expression,
|
||||
/* comma expressions, (e.g. expr1, expr2, expr3) evaluate each expression,
|
||||
* from left to right. the right-most expression sets the result of the comma
|
||||
* expression as a whole*/
|
||||
for (cl = sconsole->history.first; cl; cl = cl_next) {
|
||||
@ -8174,7 +8174,7 @@ static void expand_doit(FileData *fd, Main *mainvar, void *old)
|
||||
* This line is NEEDED, the case is that you have 3 blend files...
|
||||
* user.blend, lib.blend and lib_indirect.blend - if user.blend already references a "tree" from
|
||||
* lib_indirect.blend but lib.blend does too, linking in a Scene or Group from lib.blend can result in an
|
||||
* empty without the dupli group referenced. Once you save and reload the group would appier. - Campbell */
|
||||
* empty without the dupli group referenced. Once you save and reload the group would appear. - Campbell */
|
||||
/* This crashes files, must look further into it */
|
||||
|
||||
/* Update: the issue is that in file reading, the oldnewmap is OK, but for existing data, it has to be
|
||||
|
||||
@ -92,7 +92,7 @@ BMVert *BM_vert_create(BMesh *bm, const float co[3], const BMVert *example)
|
||||
* \brief Main function for creating a new edge.
|
||||
*
|
||||
* \note Duplicate edges are supported by the API however users should _never_ see them.
|
||||
* so unless you need a unique edge or know the edge won't exist, you should call wih \a nodouble = TRUE
|
||||
* so unless you need a unique edge or know the edge won't exist, you should call with \a nodouble = TRUE
|
||||
*/
|
||||
BMEdge *BM_edge_create(BMesh *bm, BMVert *v1, BMVert *v2, const BMEdge *example, int nodouble)
|
||||
{
|
||||
|
||||
@ -880,7 +880,7 @@ void BM_mesh_elem_hflag_enable_test(BMesh *bm, const char htype, const char hfla
|
||||
|
||||
/* note, better not attempt a fast path for selection as done with de-select
|
||||
* because hidden geometry and different selection modes can give different results,
|
||||
* we could of course check for no hiddent faces and then use quicker method but its not worth it. */
|
||||
* we could of course check for no hidden faces and then use quicker method but its not worth it. */
|
||||
|
||||
for (i = 0; i < 3; i++) {
|
||||
if (htype & flag_types[i]) {
|
||||
|
||||
@ -235,7 +235,7 @@ int BMO_op_callf(BMesh *bm, const char *fmt, ...);
|
||||
|
||||
/* initializes, but doesn't execute an operator. this is so you can
|
||||
* gain access to the outputs of the operator. note that you have
|
||||
* to execute/finitsh (BMO_op_exec and BMO_op_finish) yourself. */
|
||||
* to execute/finish (BMO_op_exec and BMO_op_finish) yourself. */
|
||||
int BMO_op_initf(BMesh *bm, BMOperator *op, const char *fmt, ...);
|
||||
|
||||
/* va_list version, used to implement the above two functions,
|
||||
|
||||
@ -712,7 +712,7 @@ static BMLoop *find_ear(BMFace *f, float (*verts)[3], const int use_beauty, floa
|
||||
}
|
||||
}
|
||||
/* Last check we do not get overlapping triangles
|
||||
* (as much as possible, ther are some cases with no good solution!) */
|
||||
* (as much as possible, there are some cases with no good solution!) */
|
||||
i4 = (i + 3) % 4;
|
||||
if (!bm_face_goodline((float const (*)[3])verts, f, BM_elem_index_get(larr[i4]->v),
|
||||
BM_elem_index_get(larr[i]->v), BM_elem_index_get(larr[i + 1]->v)))
|
||||
|
||||
@ -712,7 +712,7 @@ BMVert *BM_edge_share_vert(BMEdge *e1, BMEdge *e2)
|
||||
*
|
||||
* Finds the loop used which uses \a v in face loop \a l
|
||||
*
|
||||
* \note currenly this just uses simple loop in future may be speeded up
|
||||
* \note currently this just uses simple loop in future may be sped up
|
||||
* using radial vars
|
||||
*/
|
||||
BMLoop *BM_face_vert_share_loop(BMFace *f, BMVert *v)
|
||||
@ -735,7 +735,7 @@ BMLoop *BM_face_vert_share_loop(BMFace *f, BMVert *v)
|
||||
*
|
||||
* Finds the loop used which uses \a e in face loop \a l
|
||||
*
|
||||
* \note currenly this just uses simple loop in future may be speeded up
|
||||
* \note currently this just uses simple loop in future may be sped up
|
||||
* using radial vars
|
||||
*/
|
||||
BMLoop *BM_face_edge_share_loop(BMFace *f, BMEdge *e)
|
||||
@ -794,7 +794,7 @@ float BM_loop_calc_face_angle(BMLoop *l)
|
||||
/**
|
||||
* \brief BM_loop_calc_face_normal
|
||||
*
|
||||
* Calculate the normal at this loop corner or fallback to the face normal on straignt lines.
|
||||
* Calculate the normal at this loop corner or fallback to the face normal on straight lines.
|
||||
*
|
||||
* \param bm The BMesh
|
||||
* \param l The loop to calculate the normal at
|
||||
@ -817,7 +817,7 @@ void BM_loop_calc_face_normal(BMLoop *l, float r_normal[3])
|
||||
/**
|
||||
* \brief BM_loop_calc_face_tangent
|
||||
*
|
||||
* Calculate the tangent at this loop corner or fallback to the face normal on straignt lines.
|
||||
* Calculate the tangent at this loop corner or fallback to the face normal on straight lines.
|
||||
* This vector always points inward into the face.
|
||||
*
|
||||
* \param bm The BMesh
|
||||
@ -873,7 +873,7 @@ float BM_edge_calc_face_angle(BMEdge *e)
|
||||
/**
|
||||
* \brief BMESH EDGE/FACE TANGENT
|
||||
*
|
||||
* Calculate the tangent at this loop corner or fallback to the face normal on straignt lines.
|
||||
* Calculate the tangent at this loop corner or fallback to the face normal on straight lines.
|
||||
* This vector always points inward into the face.
|
||||
*
|
||||
* \brief BM_edge_calc_face_tangent
|
||||
|
||||
@ -34,7 +34,7 @@
|
||||
* The lowest level of functionality for manipulating bmesh structures.
|
||||
* 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.
|
||||
* in the vast majority of cases there shouldn't be used directly.
|
||||
* if absolutely necessary, see function definitions in code for
|
||||
* descriptive comments. but seriously, don't use this stuff.
|
||||
*/
|
||||
|
||||
@ -106,7 +106,7 @@ static void calc_corner_co(BMLoop *l, const float fac, float r_co[3],
|
||||
normalize_v3(l_vec_next);
|
||||
|
||||
add_v3_v3v3(co_ofs, l_vec_prev, l_vec_next);
|
||||
if (UNLIKELY(normalize_v3(co_ofs) == 0.0f)) { /* edges form a straignt line */
|
||||
if (UNLIKELY(normalize_v3(co_ofs) == 0.0f)) { /* edges form a straight line */
|
||||
cross_v3_v3v3(co_ofs, l_vec_prev, l->f->no);
|
||||
}
|
||||
|
||||
|
||||
@ -214,7 +214,7 @@ void bmo_dissolve_edgeloop_exec(BMesh *bm, BMOperator *op)
|
||||
BMO_elem_flag_enable(bm, e->v2, VERT_MARK);
|
||||
|
||||
/* BMESH_TODO - check on delaying edge removal since we may end up removing more then
|
||||
* one edge, and later referene a removed edge */
|
||||
* one edge, and later reference a removed edge */
|
||||
BM_faces_join_pair(bm, fa, fb, e, TRUE);
|
||||
}
|
||||
}
|
||||
@ -270,7 +270,7 @@ void bmo_dissolve_edges_exec(BMesh *bm, BMOperator *op)
|
||||
/* join faces */
|
||||
|
||||
/* BMESH_TODO - check on delaying edge removal since we may end up removing more then
|
||||
* one edge, and later referene a removed edge */
|
||||
* one edge, and later reference a removed edge */
|
||||
BM_faces_join_pair(bm, fa, fb, e, TRUE);
|
||||
}
|
||||
}
|
||||
|
||||
@ -61,7 +61,7 @@ typedef enum {
|
||||
HULL_FLAG_HOLE = (1 << 5)
|
||||
} HullFlags;
|
||||
|
||||
/* Store hull triangles seperate from BMesh faces until the end; this
|
||||
/* Store hull triangles separate from BMesh faces until the end; this
|
||||
* way we don't have to worry about cleaning up extraneous edges or
|
||||
* incorrectly deleting existing geometry. */
|
||||
typedef struct HullTriangle {
|
||||
|
||||
@ -280,7 +280,7 @@ void bmo_inset_exec(BMesh *bm, BMOperator *op)
|
||||
BMFace *f_b = e_info_b->l->f;
|
||||
|
||||
/* we use this as either the normal OR to find the right direction for the
|
||||
* crpss product between both face normals */
|
||||
* cross product between both face normals */
|
||||
add_v3_v3v3(tvec, e_info_a->no, e_info_b->no);
|
||||
|
||||
if ((f_a == f_b) || compare_v3v3(f_a->no, f_b->no, 0.00001f)) {
|
||||
|
||||
@ -530,7 +530,7 @@ void bmo_similar_faces_exec(BMesh *bm, BMOperator *op)
|
||||
/*
|
||||
* The first thing to do is to iterate through all the the selected items and mark them since
|
||||
* they will be in the selection anyway.
|
||||
* This will increase performance, (especially when the number of originaly selected faces is high)
|
||||
* This will increase performance, (especially when the number of originally selected faces is high)
|
||||
* so the overall complexity will be less than $O(mn)$ where is the total number of selected faces,
|
||||
* and n is the total number of faces
|
||||
*/
|
||||
|
||||
@ -1129,7 +1129,7 @@ BMesh *BME_bevel(BMEditMesh *em, float value, int res, int options, int defgrp_i
|
||||
}
|
||||
|
||||
/* possibly needed when running as a tool (which is no longer functional)
|
||||
* but keep as an optioin for now */
|
||||
* but keep as an option for now */
|
||||
if (do_tessface) {
|
||||
BMEdit_RecalcTessellation(em);
|
||||
}
|
||||
|
||||
@ -37,9 +37,9 @@ extern "C" {
|
||||
* @mainpage Introduction of the Blender Compositor
|
||||
*
|
||||
* @section bcomp Blender compositor
|
||||
* This project redesigns the interals of Blender's compositor. The project has been executed in 2011 by At Mind.
|
||||
* This project redesigns the internals of Blender's compositor. The project has been executed in 2011 by At Mind.
|
||||
* At Mind is a technology company located in Amsterdam, The Netherlands.
|
||||
* The project has been crowdfunded. This code has been released under GPL2 to be used in Blender.
|
||||
* The project has been crowd-funded. This code has been released under GPL2 to be used in Blender.
|
||||
*
|
||||
* @section goals The goals of the project
|
||||
* the new compositor has 2 goals.
|
||||
@ -58,7 +58,7 @@ extern "C" {
|
||||
* @section workflow Work faster
|
||||
* The previous compositor only showed the final image. The compositor could wait a long time before seeing the result
|
||||
* of his work. The new compositor will work in a way that it will focus on getting information back to the user.
|
||||
* It will prioritise its work to get earlier user feedback.
|
||||
* It will prioritize its work to get earlier user feedback.
|
||||
*
|
||||
* @page memory Memory model
|
||||
* The main issue is the type of memory model to use. Blender is used by consumers and professionals.
|
||||
@ -79,7 +79,7 @@ extern "C" {
|
||||
* Render priority is an priority of an output node. A user has a different need of Render priorities of output nodes
|
||||
* than during editing.
|
||||
* for example. the Active ViewerNode has top priority during editing, but during rendering a CompositeNode has.
|
||||
* All NodeOperation has a setting for their renderpriority, but only for output NodeOperation these have effect.
|
||||
* All NodeOperation has a setting for their render-priority, but only for output NodeOperation these have effect.
|
||||
* In ExecutionSystem.execute all priorities are checked. For every priority the ExecutionGroup's are check if the
|
||||
* priority do match.
|
||||
* When match the ExecutionGroup will be executed (this happens in serial)
|
||||
@ -91,18 +91,18 @@ extern "C" {
|
||||
* @section order Chunk order
|
||||
*
|
||||
* When a ExecutionGroup is executed, first the order of chunks are determined.
|
||||
* The settings are stored in the ViewerNode inside the ExecutionGroup. ExecutionGroups that have no viewernode,
|
||||
* The settings are stored in the ViewerNode inside the ExecutionGroup. ExecutionGroups that have no viewer-node,
|
||||
* will use a default one.
|
||||
* There are several possible chunk orders
|
||||
* - [@ref OrderOfChunks.COM_TO_CENTER_OUT]: Start calculating from a configurable point and order by nearest chunk
|
||||
* - [@ref OrderOfChunks.COM_TO_RANDOM]: Randomize all chunks.
|
||||
* - [@ref OrderOfChunks.COM_TO_TOP_DOWN]: Start calculation from the bottom to the top of the image
|
||||
* - [@ref OrderOfChunks.COM_TO_RULE_OF_THIRDS]: Experimental order based on 9 hotspots in the image
|
||||
* - [@ref OrderOfChunks.COM_TO_RULE_OF_THIRDS]: Experimental order based on 9 hot-spots in the image
|
||||
*
|
||||
* When the chunkorder is determined, the first few chunks will be checked if they can be scheduled.
|
||||
* When the chunk-order is determined, the first few chunks will be checked if they can be scheduled.
|
||||
* Chunks can have three states:
|
||||
* - [@ref ChunkExecutionState.COM_ES_NOT_SCHEDULED]: Chunk is not yet scheduled, or dependacies are not met
|
||||
* - [@ref ChunkExecutionState.COM_ES_SCHEDULED]: All dependacies are met, chunk is scheduled, but not finished
|
||||
* - [@ref ChunkExecutionState.COM_ES_NOT_SCHEDULED]: Chunk is not yet scheduled, or dependencies are not met
|
||||
* - [@ref ChunkExecutionState.COM_ES_SCHEDULED]: All dependencies are met, chunk is scheduled, but not finished
|
||||
* - [@ref ChunkExecutionState.COM_ES_EXECUTED]: Chunk is finished
|
||||
*
|
||||
* @see ExecutionGroup.execute
|
||||
@ -110,7 +110,7 @@ extern "C" {
|
||||
* @see OrderOfChunks
|
||||
*
|
||||
* @section interest Area of interest
|
||||
* An ExecutionGroup can have dependancies to other ExecutionGroup's. Data passing from one ExecutionGroup to another
|
||||
* An ExecutionGroup can have dependencies to other ExecutionGroup's. Data passing from one ExecutionGroup to another
|
||||
* one are stored in 'chunks'.
|
||||
* If not all input chunks are available the chunk execution will not be scheduled.
|
||||
* <pre>
|
||||
@ -217,22 +217,22 @@ extern "C" {
|
||||
* @section workscheduler WorkScheduler
|
||||
* the WorkScheduler is implemented as a static class. the responsibility of the WorkScheduler is to balance
|
||||
* WorkPackages to the available and free devices.
|
||||
* the workscheduler can work in 2 states. For witching these between the state you need to recompile blender
|
||||
* the work-scheduler can work in 2 states. For witching these between the state you need to recompile blender
|
||||
*
|
||||
* @subsection multithread Multi threaded
|
||||
* Default the workscheduler will place all work as WorkPackage in a queue.
|
||||
* Default the work-scheduler will place all work as WorkPackage in a queue.
|
||||
* For every CPUcore a working thread is created. These working threads will ask the WorkScheduler if there is work
|
||||
* for a specific Device.
|
||||
* the workscheduler will find work for the device and the device will be asked to execute the WorkPackage
|
||||
* the work-scheduler will find work for the device and the device will be asked to execute the WorkPackage
|
||||
*
|
||||
* @subsection singlethread Single threaded
|
||||
* For debugging reasons the multi-threading can be disabled. This is done by changing the COM_CURRENT_THREADING_MODEL
|
||||
* to COM_TM_NOTHREAD. When compiling the workscheduler
|
||||
* to COM_TM_NOTHREAD. When compiling the work-scheduler
|
||||
* will be changes to support no threading and run everything on the CPU.
|
||||
*
|
||||
* @section devices Devices
|
||||
* A Device within the compositor context is a Hardware component that can used to calculate chunks.
|
||||
* This chunk is encapseled in a WorkPackage.
|
||||
* This chunk is encapsulated in a WorkPackage.
|
||||
* the WorkScheduler controls the devices and selects the device where a WorkPackage will be calculated.
|
||||
*
|
||||
* @subsection WS_Devices Workscheduler
|
||||
|
||||
@ -180,7 +180,7 @@ private:
|
||||
|
||||
/**
|
||||
* @brief Determine the rect (minx, maxx, miny, maxy) of a chunk at a position.
|
||||
* @note Only gives usefull results ater the determination of the chunksize
|
||||
* @note Only gives useful results ater the determination of the chunksize
|
||||
* @see determineChunkSize()
|
||||
*/
|
||||
void determineChunkRect(rcti *rect, const unsigned int xChunk, const unsigned int yChunk) const;
|
||||
@ -376,7 +376,7 @@ public:
|
||||
|
||||
/**
|
||||
* @brief Determine the rect (minx, maxx, miny, maxy) of a chunk.
|
||||
* @note Only gives usefull results ater the determination of the chunksize
|
||||
* @note Only gives useful results ater the determination of the chunksize
|
||||
* @see determineChunkSize()
|
||||
*/
|
||||
void determineChunkRect(rcti *rect, const unsigned int chunkNumber) const;
|
||||
|
||||
@ -37,7 +37,7 @@ using namespace std;
|
||||
|
||||
/**
|
||||
* @page execution Execution model
|
||||
* In order to get to an efficient model for execution, serveral steps are being done. these steps are explained below.
|
||||
* In order to get to an efficient model for execution, several steps are being done. these steps are explained below.
|
||||
*
|
||||
* @section EM_Step1 Step 1: translating blender node system to the new compsitor system
|
||||
* Blenders node structure is based on C structs (DNA). These structs are not efficient in the new architecture. We want to use classes in order to simplify the system.
|
||||
@ -64,7 +64,7 @@ using namespace std;
|
||||
* @section EM_Step3 Step3: add additional conversions to the operation system
|
||||
* - Data type conversions: the system has 3 data types COM_DT_VALUE, COM_DT_VECTOR, COM_DT_COLOR. The user can connect a Value socket to a color socket. As values are ordered differently than colors a conversion happens.
|
||||
*
|
||||
* - Image size conversions: the system can automatically convert when resolutions do not match. An InputSocket has a resize mode. This can be any of the folowing settings.
|
||||
* - Image size conversions: the system can automatically convert when resolutions do not match. An InputSocket has a resize mode. This can be any of the following settings.
|
||||
* - [@ref InputSocketResizeMode.COM_SC_CENTER]: The center of both images are aligned
|
||||
* - [@ref InputSocketResizeMode.COM_SC_FIT_WIDTH]: The width of both images are aligned
|
||||
* - [@ref InputSocketResizeMode.COM_SC_FIT_HEIGHT]: the height of both images are aligned
|
||||
|
||||
@ -67,7 +67,7 @@ private:
|
||||
|
||||
|
||||
/**
|
||||
* @brief region of this buffer inside reative to the MemoryProxy
|
||||
* @brief region of this buffer inside relative to the MemoryProxy
|
||||
*/
|
||||
rcti m_rect;
|
||||
|
||||
@ -218,7 +218,7 @@ public:
|
||||
int getHeight() const;
|
||||
|
||||
/**
|
||||
* @brief clear the buffer. Make all pixels black transparant.
|
||||
* @brief clear the buffer. Make all pixels black transparent.
|
||||
*/
|
||||
void clear();
|
||||
|
||||
|
||||
@ -89,7 +89,7 @@ public:
|
||||
WriteBufferOperation *getWriteBufferOperation() { return this->m_writeBufferOperation; }
|
||||
|
||||
/**
|
||||
* @brief allocate memory of size widht x height
|
||||
* @brief allocate memory of size width x height
|
||||
*/
|
||||
void allocate(unsigned int width, unsigned int height);
|
||||
|
||||
|
||||
@ -74,7 +74,7 @@ public:
|
||||
/**
|
||||
* @brief convert node to operation
|
||||
*
|
||||
* @todo this must be described furter
|
||||
* @todo this must be described further
|
||||
*
|
||||
* @param system the ExecutionSystem where the operations need to be added
|
||||
* @param context reference to the CompositorContext
|
||||
|
||||
@ -101,7 +101,7 @@ public:
|
||||
/**
|
||||
* @brief isOutputOperation determines whether this operation is an output of the ExecutionSystem during rendering or editing.
|
||||
*
|
||||
* Default behaviour if not overriden, this operation will not be evaluated as being an output of the ExecutionSystem.
|
||||
* Default behaviour if not overridden, this operation will not be evaluated as being an output of the ExecutionSystem.
|
||||
*
|
||||
* @see ExecutionSystem
|
||||
* @group check
|
||||
|
||||
@ -894,7 +894,7 @@ static void do_createEdgeLocationBuffer(unsigned int t, unsigned int rw, unsigne
|
||||
int x; // x = pixel loop counter
|
||||
int a; // a = temporary pixel index buffer loop counter
|
||||
unsigned int ud; // ud = unscaled edge distance
|
||||
unsigned int dmin; // dmin = minimun edge distance
|
||||
unsigned int dmin; // dmin = minimum edge distance
|
||||
|
||||
unsigned int rsl; // long used for finding fast 1.0/sqrt
|
||||
unsigned int gradientFillOffset;
|
||||
@ -1012,7 +1012,7 @@ static void do_fillGradientBuffer(unsigned int rw, float *res, unsigned short *g
|
||||
unsigned int gradientFillOffset;
|
||||
unsigned int t;
|
||||
unsigned int ud; // ud = unscaled edge distance
|
||||
unsigned int dmin; // dmin = minimun edge distance
|
||||
unsigned int dmin; // dmin = minimum edge distance
|
||||
float odist; // odist = current outer edge distance
|
||||
float idist; // idist = current inner edge distance
|
||||
int dx; // dx = X-delta (used for distance proportion calculation)
|
||||
@ -1070,7 +1070,7 @@ static void do_fillGradientBuffer(unsigned int rw, float *res, unsigned short *g
|
||||
* pixel color as |GI| / (|GI| + |GO|). Since these are reciprocals, GI serves the
|
||||
* purpose of GO for the proportion calculation.
|
||||
*
|
||||
* For the purposes of the minimun distance comparisons, we only check
|
||||
* For the purposes of the minimum distance comparisons, we only check
|
||||
* the sums-of-squares against eachother, since they are in the same
|
||||
* mathematical sort-order as if we did go ahead and take square roots
|
||||
*
|
||||
@ -1116,7 +1116,7 @@ static void do_fillGradientBuffer(unsigned int rw, float *res, unsigned short *g
|
||||
/*
|
||||
* Note once again that since we are using reciprocals of distance values our
|
||||
* proportion is already the correct intensity, and does not need to be
|
||||
* subracted from 1.0 like it would have if we used real distances.
|
||||
* subtracted from 1.0 like it would have if we used real distances.
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
@ -27,7 +27,7 @@
|
||||
#include "COM_NodeOperation.h"
|
||||
|
||||
/**
|
||||
* Class with implementation of bluring for keying node
|
||||
* Class with implementation of blurring for keying node
|
||||
*/
|
||||
class KeyingBlurOperation : public NodeOperation {
|
||||
protected:
|
||||
|
||||
@ -851,7 +851,7 @@ static int acf_group_setting_flag(bAnimContext *ac, int setting, short *neg)
|
||||
// *neg = 1; - if we change this to edtiability
|
||||
return AGRP_PROTECTED;
|
||||
|
||||
case ACHANNEL_SETTING_VISIBLE: /* visiblity - graph editor */
|
||||
case ACHANNEL_SETTING_VISIBLE: /* visibility - graph editor */
|
||||
*neg = 1;
|
||||
return AGRP_NOTVISIBLE;
|
||||
}
|
||||
@ -939,7 +939,7 @@ static int acf_fcurve_setting_flag(bAnimContext *UNUSED(ac), int setting, short
|
||||
// *neg = 1; - if we change this to edtiability
|
||||
return FCURVE_PROTECTED;
|
||||
|
||||
case ACHANNEL_SETTING_VISIBLE: /* visiblity - graph editor */
|
||||
case ACHANNEL_SETTING_VISIBLE: /* visibility - graph editor */
|
||||
return FCURVE_VISIBLE;
|
||||
|
||||
default: /* unsupported */
|
||||
|
||||
@ -1818,7 +1818,7 @@ void UI_view2d_scrollers_free(View2DScrollers *scrollers)
|
||||
* This should be (0,0) for most views. However, for those where the starting row was offsetted
|
||||
* (like for Animation Editor channel lists, to make the first entry more visible), these will be
|
||||
* the min-coordinates of the first item.
|
||||
* - column, row = the 2d-corodinates (in 2D-view / 'tot' rect space) the cell exists at
|
||||
* - column, row = the 2d-coordinates (in 2D-view / 'tot' rect space) the cell exists at
|
||||
* - rect = coordinates of the cell (passed as single var instead of 4 separate, as it's more useful this way)
|
||||
*/
|
||||
void UI_view2d_listview_cell_to_view(View2D *v2d, short columnwidth, short rowheight, float startx, float starty, int column, int row, rctf *rect)
|
||||
|
||||
@ -202,7 +202,7 @@ static int group_objects_remove_exec(bContext *C, wmOperator *op)
|
||||
Scene *scene = CTX_data_scene(C);
|
||||
int group_object_index = RNA_enum_get(op->ptr, "group");
|
||||
|
||||
/* first get the group back from the enum index, quite awkward and UI spesific */
|
||||
/* first get the group back from the enum index, quite awkward and UI specific */
|
||||
if (ob) {
|
||||
Group *group = NULL;
|
||||
int i = 0;
|
||||
|
||||
@ -913,7 +913,7 @@ static int fluidsimBake(bContext *C, ReportList *reports, Object *fsDomain, shor
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* these both have to be valid, otherwise we wouldnt be here */
|
||||
/* these both have to be valid, otherwise we wouldn't be here */
|
||||
fluidmd = (FluidsimModifierData *)modifiers_findByType(fsDomain, eModifierType_Fluidsim);
|
||||
domainSettings = fluidmd->fss;
|
||||
mesh = fsDomain->data;
|
||||
|
||||
@ -3017,7 +3017,7 @@ static int screen_animation_step(bContext *C, wmOperator *UNUSED(op), wmEvent *e
|
||||
}
|
||||
}
|
||||
|
||||
/* next frame overriden by user action (pressed jump to first/last frame) */
|
||||
/* next frame overridden by user action (pressed jump to first/last frame) */
|
||||
if (sad->flag & ANIMPLAY_FLAG_USE_NEXT_FRAME) {
|
||||
scene->r.cfra = sad->nextfra;
|
||||
sad->flag &= ~ANIMPLAY_FLAG_USE_NEXT_FRAME;
|
||||
|
||||
@ -604,7 +604,7 @@ void paint_partial_visibility_keys(wmKeyMap *keymap)
|
||||
{
|
||||
wmKeyMapItem *kmi;
|
||||
|
||||
/* Partial visiblity */
|
||||
/* Partial visibility */
|
||||
kmi = WM_keymap_add_item(keymap, "PAINT_OT_hide_show", HKEY, KM_PRESS, KM_SHIFT, 0);
|
||||
RNA_enum_set(kmi->ptr, "action", PARTIALVIS_SHOW);
|
||||
RNA_enum_set(kmi->ptr, "area", PARTIALVIS_INSIDE);
|
||||
|
||||
@ -2843,7 +2843,7 @@ static void draw_em_fancy_edges(BMEditMesh *em, Scene *scene, View3D *v3d,
|
||||
int pass;
|
||||
unsigned char wireCol[4], selCol[4], actCol[4];
|
||||
|
||||
/* since this function does transparant... */
|
||||
/* since this function does transparent... */
|
||||
UI_GetThemeColor4ubv(TH_EDGE_SELECT, selCol);
|
||||
UI_GetThemeColor4ubv(TH_WIRE, wireCol);
|
||||
UI_GetThemeColor4ubv(TH_EDITMESH_ACTIVE, actCol);
|
||||
@ -2854,7 +2854,7 @@ static void draw_em_fancy_edges(BMEditMesh *em, Scene *scene, View3D *v3d,
|
||||
wireCol[3] = 0;
|
||||
|
||||
for (pass = 0; pass < 2; pass++) {
|
||||
/* show wires in transparant when no zbuf clipping for select */
|
||||
/* show wires in transparent when no zbuf clipping for select */
|
||||
if (pass == 0) {
|
||||
if (v3d->zbuf && (v3d->flag & V3D_ZBUF_SELECT) == 0) {
|
||||
glEnable(GL_BLEND);
|
||||
|
||||
@ -1595,7 +1595,7 @@ static int gpu_count_grid_quads(BLI_bitmap *grid_hidden,
|
||||
int i, x, y, totquad;
|
||||
|
||||
/* grid hidden layer is present, so have to check each grid for
|
||||
* visiblity */
|
||||
* visibility */
|
||||
|
||||
for (i = 0, totquad = 0; i < totgrid; i++) {
|
||||
const BLI_bitmap gh = grid_hidden[grid_indices[i]];
|
||||
|
||||
@ -35,7 +35,7 @@
|
||||
#include "BLI_utildefines.h"
|
||||
#include "BLI_ghash.h"
|
||||
|
||||
/* Cache system for movie data - now supports stoting ImBufs only
|
||||
/* Cache system for movie data - now supports storing ImBufs only
|
||||
* Supposed to provide unified cache system for movie clips, sequencer and
|
||||
* other movie-related areas */
|
||||
|
||||
|
||||
@ -36,12 +36,6 @@
|
||||
*
|
||||
*/
|
||||
|
||||
/* imageprocess.c MIXED MODEL
|
||||
*
|
||||
* april 95
|
||||
*
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "BLI_utildefines.h"
|
||||
|
||||
@ -864,7 +864,7 @@ int imb_savejp2(struct ImBuf *ibuf, const char *name, int flags)
|
||||
|
||||
/*
|
||||
* configure the event callbacks (not required)
|
||||
* setting of each callback is optionnal
|
||||
* setting of each callback is optional
|
||||
*/
|
||||
memset(&event_mgr, 0, sizeof(opj_event_mgr_t));
|
||||
event_mgr.error_handler = error_callback;
|
||||
|
||||
@ -67,8 +67,8 @@ static ImBuf *ibJpegImageFromCinfo(struct jpeg_decompress_struct *cinfo, int fla
|
||||
/*
|
||||
* In principle there are 4 jpeg formats.
|
||||
*
|
||||
* 1. jpeg - standard printing, u & v at quarter of resulution
|
||||
* 2. jvid - standaard video, u & v half resolution, frame not interlaced
|
||||
* 1. jpeg - standard printing, u & v at quarter of resolution
|
||||
* 2. jvid - standard video, u & v half resolution, frame not interlaced
|
||||
*
|
||||
* type 3 is unsupported as of jul 05 2000 Frank.
|
||||
*
|
||||
|
||||
@ -774,7 +774,7 @@ static void q_scale_float(float *in, float *out, int in_width,
|
||||
* Should be comparable in speed to the ImBuf ..._fast functions at least
|
||||
* for byte-buffers.
|
||||
*
|
||||
* NOTE: disabled, due to inacceptable inaccuracy and quality loss, see bug #18609 (ton)
|
||||
* NOTE: disabled, due to unacceptable inaccuracy and quality loss, see bug #18609 (ton)
|
||||
*/
|
||||
static int q_scale_linear_interpolation(
|
||||
struct ImBuf *ibuf, int newx, int newy)
|
||||
@ -1460,7 +1460,7 @@ struct ImBuf *IMB_scaleImBuf(struct ImBuf *ibuf, unsigned int newx, unsigned int
|
||||
scalefast_Z_ImBuf(ibuf, newx, newy);
|
||||
|
||||
/* try to scale common cases in a fast way */
|
||||
/* disabled, quality loss is inacceptable, see report #18609 (ton) */
|
||||
/* disabled, quality loss is unacceptable, see report #18609 (ton) */
|
||||
if (0 && q_scale_linear_interpolation(ibuf, newx, newy)) {
|
||||
return ibuf;
|
||||
}
|
||||
|
||||
@ -628,7 +628,7 @@ typedef enum eNlaStrip_Flag {
|
||||
/* NLA strip length is synced to the length of the referenced action */
|
||||
NLASTRIP_FLAG_SYNC_LENGTH = (1<<9),
|
||||
|
||||
/* playback flags (may be overriden by F-Curves) */
|
||||
/* playback flags (may be overridden by F-Curves) */
|
||||
/* NLA strip blendin/out values are set automatically based on overlaps */
|
||||
NLASTRIP_FLAG_AUTO_BLENDS = (1<<10),
|
||||
/* NLA strip is played back in reverse order */
|
||||
|
||||
@ -204,7 +204,7 @@ typedef struct Tex {
|
||||
/* newnoise: musgrave parameters */
|
||||
float mg_H, mg_lacunarity, mg_octaves, mg_offset, mg_gain;
|
||||
|
||||
/* newnoise: distorted noise amount, musgrave & voronoi ouput scale */
|
||||
/* newnoise: distorted noise amount, musgrave & voronoi output scale */
|
||||
float dist_amount, ns_outscale;
|
||||
|
||||
/* newnoise: voronoi nearest neighbor weights, minkovsky exponent, distance metric & color type */
|
||||
|
||||
@ -105,7 +105,7 @@ typedef long long __int64;
|
||||
* - location within a struct (everthing can be randomly mixed up)
|
||||
* - struct within struct (within struct etc), this is recursive
|
||||
* - adding new elements, will be default initialized zero
|
||||
* - remving elements
|
||||
* - removing elements
|
||||
* - change of array sizes
|
||||
* - change of a pointer type: when the name doesn't change the contents is copied
|
||||
*
|
||||
@ -122,7 +122,7 @@ typedef long long __int64;
|
||||
* - only use a long in Blender if you want this to be the size of a pointer. so it is
|
||||
* 32 bits or 64 bits, dependent at the cpu architecture
|
||||
* - chars are always unsigned
|
||||
* - aligment of variables has to be done in such a way, that any system does
|
||||
* - alignment of variables has to be done in such a way, that any system does
|
||||
* not create 'padding' (gaps) in structures. So make sure that:
|
||||
* - short: 2 aligned
|
||||
* - int: 4 aligned
|
||||
@ -556,7 +556,7 @@ static void recurs_test_compflags(SDNA *sdna, char *compflags, int structnr)
|
||||
|
||||
/* Unsure of exact function - compares the sdna argument to
|
||||
* newsdna and sets up the information necessary to convert
|
||||
* data written with a dna of oldsdna to inmemory data with a
|
||||
* data written with a dna of oldsdna to in-memory data with a
|
||||
* structure defined by the newsdna sdna (I think). -zr
|
||||
*/
|
||||
|
||||
|
||||
@ -203,7 +203,7 @@ typedef enum PropertyFlag {
|
||||
PROP_CONTEXT_UPDATE = (1 << 22),
|
||||
PROP_CONTEXT_PROPERTY_UPDATE = (1 << 22) | (1 << 27),
|
||||
|
||||
/* Use for arrays or for any data that should not have a referene kept
|
||||
/* Use for arrays or for any data that should not have a reference kept
|
||||
* most common case is functions that return arrays where the array */
|
||||
PROP_THICK_WRAP = (1 << 23),
|
||||
|
||||
|
||||
@ -60,7 +60,7 @@ void rna_Scene_frame_set(Scene *scene, int frame, float subframe)
|
||||
BKE_scene_update_for_newframe(G.main, scene, (1 << 20) - 1);
|
||||
BKE_scene_camera_switch_update(scene);
|
||||
|
||||
/* cant use NC_SCENE|ND_FRAME because this casues wm_event_do_notifiers to call
|
||||
/* cant use NC_SCENE|ND_FRAME because this causes wm_event_do_notifiers to call
|
||||
* BKE_scene_update_for_newframe which will loose any un-keyed changes [#24690] */
|
||||
/* WM_main_add_notifier(NC_SCENE|ND_FRAME, scene); */
|
||||
|
||||
|
||||
@ -59,7 +59,7 @@ typedef struct EffectInfo {
|
||||
|
||||
#ifdef RNA_RUNTIME
|
||||
|
||||
/* build a temp referene to the parent */
|
||||
/* build a temp reference to the parent */
|
||||
static void meta_tmp_ref(Sequence *seq_par, Sequence *seq)
|
||||
{
|
||||
for (; seq; seq = seq->next) {
|
||||
|
||||
@ -189,7 +189,7 @@ static int *find_doubles_index_map(BMesh *bm, BMOperator *dupe_op,
|
||||
i++;
|
||||
}
|
||||
/* above loops over all, so set all to dirty, if this is somehow
|
||||
* setting valid values, this line can be remvoed - campbell */
|
||||
* setting valid values, this line can be removed - campbell */
|
||||
bm->elem_index_dirty |= BM_VERT | BM_EDGE | BM_FACE;
|
||||
|
||||
(*index_map_length) = i;
|
||||
|
||||
@ -199,7 +199,7 @@ static CustomDataMask requiredDataMask(Object *UNUSED(ob), ModifierData *md)
|
||||
return dataMask;
|
||||
}
|
||||
|
||||
/* spesific function for solidify - define locally */
|
||||
/* specific function for solidify - define locally */
|
||||
BLI_INLINE void madd_v3v3short_fl(float r[3], const short a[3], const float f)
|
||||
{
|
||||
r[0] += (float)a[0] * f;
|
||||
|
||||
@ -183,7 +183,7 @@ static float get_ob2ob_distance(const Object *ob, const Object *obr)
|
||||
}
|
||||
|
||||
/**
|
||||
* Maps distances to weights, with an optionnal "smoothing" mapping.
|
||||
* Maps distances to weights, with an optional "smoothing" mapping.
|
||||
*/
|
||||
void do_map(float *weights, const int nidx, const float min_d, const float max_d, short mode)
|
||||
{
|
||||
|
||||
@ -909,7 +909,7 @@ static void do_createEdgeLocationBuffer(unsigned int t, unsigned int rw, unsigne
|
||||
int x; // x = pixel loop counter
|
||||
int a; // a = temporary pixel index buffer loop counter
|
||||
unsigned int ud; // ud = unscaled edge distance
|
||||
unsigned int dmin; // dmin = minimun edge distance
|
||||
unsigned int dmin; // dmin = minimum edge distance
|
||||
|
||||
unsigned int rsl; // long used for finding fast 1.0/sqrt
|
||||
unsigned int gradientFillOffset;
|
||||
@ -1027,7 +1027,7 @@ static void do_fillGradientBuffer(unsigned int rw, float *res, unsigned short *g
|
||||
unsigned int gradientFillOffset;
|
||||
unsigned int t;
|
||||
unsigned int ud; // ud = unscaled edge distance
|
||||
unsigned int dmin; // dmin = minimun edge distance
|
||||
unsigned int dmin; // dmin = minimum edge distance
|
||||
float odist; // odist = current outer edge distance
|
||||
float idist; // idist = current inner edge distance
|
||||
int dx; // dx = X-delta (used for distance proportion calculation)
|
||||
@ -1084,7 +1084,7 @@ static void do_fillGradientBuffer(unsigned int rw, float *res, unsigned short *g
|
||||
* pixel color as |GI| / (|GI| + |GO|). Since these are reciprocals, GI serves the
|
||||
* purpose of GO for the proportion calculation.
|
||||
*
|
||||
* For the purposes of the minimun distance comparisons, we only check
|
||||
* For the purposes of the minimum distance comparisons, we only check
|
||||
* the sums-of-squares against each other, since they are in the same
|
||||
* mathematical sort-order as if we did go ahead and take square roots
|
||||
*
|
||||
@ -1130,7 +1130,7 @@ static void do_fillGradientBuffer(unsigned int rw, float *res, unsigned short *g
|
||||
/*
|
||||
* Note once again that since we are using reciprocals of distance values our
|
||||
* proportion is already the correct intensity, and does not need to be
|
||||
* subracted from 1.0 like it would have if we used real distances.
|
||||
* subtracted from 1.0 like it would have if we used real distances.
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
@ -211,7 +211,7 @@ void node_gpu_stack_from_data(struct GPUNodeStack *gs, int type, bNodeStack *ns)
|
||||
|
||||
gs->name = "";
|
||||
gs->hasinput= ns->hasinput && ns->data;
|
||||
/* XXX Commented out the ns->data check here, as it seems it's not alwas set,
|
||||
/* XXX Commented out the ns->data check here, as it seems it's not always set,
|
||||
* even though there *is* a valid connection/output... But that might need
|
||||
* further investigation.
|
||||
*/
|
||||
|
||||
@ -1578,7 +1578,7 @@ PyDoc_STRVAR(bpy_bmloop_calc_normal_doc,
|
||||
".. method:: calc_normal()\n"
|
||||
"\n"
|
||||
" Return normal at this loops corner of the face.\n"
|
||||
" Falls back to the face normal for straignt lines.\n"
|
||||
" Falls back to the face normal for straight lines.\n"
|
||||
"\n"
|
||||
" :return: a normalized vector.\n"
|
||||
" :rtype: :class:`mathutils.Vector`\n"
|
||||
@ -1595,7 +1595,7 @@ PyDoc_STRVAR(bpy_bmloop_calc_tangent_doc,
|
||||
".. method:: calc_tangent()\n"
|
||||
"\n"
|
||||
" Return the tangent at this loops corner of the face (pointing inward into the face).\n"
|
||||
" Falls back to the face normal for straignt lines.\n"
|
||||
" Falls back to the face normal for straight lines.\n"
|
||||
"\n"
|
||||
" :return: a normalized vector.\n"
|
||||
" :rtype: :class:`mathutils.Vector`\n"
|
||||
|
||||
@ -363,7 +363,7 @@ PyObject *BPy_BMLoopColor_CreatePyObject(struct MLoopCol *data)
|
||||
* weight = dv[group_nr]
|
||||
* del dv[group_nr]
|
||||
*
|
||||
* \note: there is nothing BMesh spesific here,
|
||||
* \note: there is nothing BMesh specific here,
|
||||
* its only that BMesh is the only part of blender that uses a hand written api like this.
|
||||
* This type could eventually be used to access lattice weights.
|
||||
*
|
||||
|
||||
@ -29,7 +29,7 @@
|
||||
* This file defines the types for 'BMesh.select_history'
|
||||
* sequence and iterator.
|
||||
*
|
||||
* select_history is very loosely based on pytons set() type,
|
||||
* select_history is very loosely based on pythons set() type,
|
||||
* since items can only exist once. however they do have an order.
|
||||
*/
|
||||
|
||||
|
||||
@ -287,7 +287,7 @@ static PyObject *blender_import(PyObject *UNUSED(self), PyObject *args, PyObject
|
||||
}
|
||||
else {
|
||||
/* no blender text was found that could import the module
|
||||
* rause the original error from PyImport_ImportModuleEx */
|
||||
* reuse the original error from PyImport_ImportModuleEx */
|
||||
PyErr_Restore(exception, err, tb);
|
||||
}
|
||||
return newmodule;
|
||||
|
||||
@ -152,7 +152,7 @@ PyObject *BPy_IDGroup_WrapData(ID *id, IDProperty *prop, IDProperty *parent)
|
||||
}
|
||||
}
|
||||
|
||||
#if 0 /* UNUSED, currenly assignment overwrites into new properties, rather than setting in-place */
|
||||
#if 0 /* UNUSED, currently assignment overwrites into new properties, rather than setting in-place */
|
||||
static int BPy_IDGroup_SetData(BPy_IDProperty *self, IDProperty *prop, PyObject *value)
|
||||
{
|
||||
switch (prop->type) {
|
||||
|
||||
@ -229,7 +229,7 @@ PyObject *PyC_Object_GetAttrStringArgs(PyObject *o, Py_ssize_t n, ...)
|
||||
/* similar to PyErr_Format(),
|
||||
*
|
||||
* implementation - we cant actually preprend the existing exception,
|
||||
* because it could have _any_ argiments given to it, so instead we get its
|
||||
* because it could have _any_ arguments given to it, so instead we get its
|
||||
* __str__ output and raise our own exception including it.
|
||||
*/
|
||||
PyObject *PyC_Err_Format_Prefix(PyObject *exception_type_prefix, const char *format, ...)
|
||||
|
||||
@ -232,7 +232,7 @@ static PyObject *pyop_call(PyObject *UNUSED(self), PyObject *args)
|
||||
#ifdef BPY_RELEASE_GIL
|
||||
/* release GIL, since a thread could be started from an operator
|
||||
* that updates a driver */
|
||||
/* note: I havve not seen any examples of code that does this
|
||||
/* note: I have not seen any examples of code that does this
|
||||
* so it may not be officially supported but seems to work ok. */
|
||||
{
|
||||
PyThreadState *ts = PyEval_SaveThread();
|
||||
|
||||
@ -307,7 +307,7 @@ static int py_long_as_int(PyObject *py_long, int *r_int)
|
||||
} (void)0
|
||||
|
||||
/* terse macros for error checks shared between all funcs cant use function
|
||||
* calls because of static strins passed to pyrna_set_to_enum_bitfield */
|
||||
* calls because of static strings passed to pyrna_set_to_enum_bitfield */
|
||||
#define BPY_PROPDEF_CHECK(_func, _property_flag_items) \
|
||||
if (id_len >= MAX_IDPROP_NAME) { \
|
||||
PyErr_Format(PyExc_TypeError, \
|
||||
|
||||
@ -7000,7 +7000,7 @@ static int bpy_class_call(bContext *C, PointerRNA *ptr, FunctionRNA *func, Param
|
||||
Py_INCREF(py_class_instance);
|
||||
#endif
|
||||
/*
|
||||
* This would work fine but means __init__ functions wouldnt run.
|
||||
* This would work fine but means __init__ functions wouldn't run.
|
||||
* none of blenders default scripts use __init__ but its nice to call it
|
||||
* for general correctness. just to note why this is here when it could be safely removed.
|
||||
*/
|
||||
|
||||
@ -342,7 +342,7 @@ static char *copy_values(PyObject *seq, PointerRNA *ptr, PropertyRNA *prop,
|
||||
|
||||
/* Regarding PySequence_GetItem() failing.
|
||||
*
|
||||
* This should never be NULL since we validated it, _but_ some triky python
|
||||
* This should never be NULL since we validated it, _but_ some tricky python
|
||||
* developer could write their own sequence type which succeeds on
|
||||
* validating but fails later somehow, so include checks for safety.
|
||||
*/
|
||||
|
||||
@ -147,7 +147,7 @@ static PyObject *Color_str(ColorObject *self)
|
||||
}
|
||||
|
||||
//------------------------tp_richcmpr
|
||||
//returns -1 execption, 0 false, 1 true
|
||||
//returns -1 exception, 0 false, 1 true
|
||||
static PyObject *Color_richcmpr(PyObject *a, PyObject *b, int op)
|
||||
{
|
||||
PyObject *res;
|
||||
|
||||
@ -2443,7 +2443,7 @@ PyObject *Matrix_CreatePyObject_cb(PyObject *cb_user,
|
||||
|
||||
|
||||
/* ----------------------------------------------------------------------------
|
||||
* special type for alaternate access */
|
||||
* special type for alternate access */
|
||||
|
||||
typedef struct {
|
||||
PyObject_HEAD /* required python macro */
|
||||
|
||||
@ -1864,7 +1864,7 @@ static double vec_magnitude_nosqrt(float *data, int size)
|
||||
|
||||
|
||||
/*------------------------tp_richcmpr
|
||||
* returns -1 execption, 0 false, 1 true */
|
||||
* returns -1 exception, 0 false, 1 true */
|
||||
static PyObject *Vector_richcmpr(PyObject *objectA, PyObject *objectB, int comparison_type)
|
||||
{
|
||||
VectorObject *vecA = NULL, *vecB = NULL;
|
||||
@ -2908,7 +2908,7 @@ PyObject *Vector_CreatePyObject(float *vec, const int size, const int type, PyTy
|
||||
}
|
||||
else { /* new empty */
|
||||
fill_vn_fl(self->vec, size, 0.0f);
|
||||
if (size == 4) { /* do the homogenous thing */
|
||||
if (size == 4) { /* do the homogeneous thing */
|
||||
self->vec[3] = 1.0f;
|
||||
}
|
||||
}
|
||||
|
||||
@ -400,13 +400,13 @@ int start_qt(struct Scene *scene, struct RenderData *rd, int rectx, int recty, R
|
||||
qtexport->audioInputFormat.mFormatFlags |= kLinearPCMFormatFlagIsPacked;
|
||||
|
||||
|
||||
/*Ouput format*/
|
||||
/*Output format*/
|
||||
qtexport->audioOutputFormat.mFormatID = rd->qtcodecsettings.audiocodecType;
|
||||
//TODO: set audio channels
|
||||
qtexport->audioOutputFormat.mChannelsPerFrame = 2;
|
||||
qtexport->audioOutputFormat.mSampleRate = rd->qtcodecsettings.audioSampleRate;
|
||||
|
||||
/* Default value for compressed formats, overriden after if not the case */
|
||||
/* Default value for compressed formats, overridden after if not the case */
|
||||
qtexport->audioOutputFormat.mFramesPerPacket = 0;
|
||||
qtexport->audioOutputFormat.mBytesPerFrame = 0;
|
||||
qtexport->audioOutputFormat.mBytesPerPacket = 0;
|
||||
|
||||
@ -85,7 +85,7 @@ int anim_is_quicktime (const char *name)
|
||||
if( BLI_testextensie(name, ".swf") ||
|
||||
BLI_testextensie(name, ".txt") ||
|
||||
BLI_testextensie(name, ".mpg") ||
|
||||
BLI_testextensie(name, ".avi") || // wouldnt be appropriate ;)
|
||||
BLI_testextensie(name, ".avi") || // wouldn't be appropriate ;)
|
||||
BLI_testextensie(name, ".mov") || // disabled, suboptimal decoding speed
|
||||
BLI_testextensie(name, ".mp4") || // disabled, suboptimal decoding speed
|
||||
BLI_testextensie(name, ".m4v") || // disabled, suboptimal decoding speed
|
||||
|
||||
@ -195,7 +195,7 @@ int anim_is_quicktime(const char *name)
|
||||
if (BLI_testextensie(name, ".swf") ||
|
||||
BLI_testextensie(name, ".txt") ||
|
||||
BLI_testextensie(name, ".mpg") ||
|
||||
BLI_testextensie(name, ".avi") || /* wouldnt be appropriate ;) */
|
||||
BLI_testextensie(name, ".avi") || /* wouldn't be appropriate ;) */
|
||||
BLI_testextensie(name, ".tga") ||
|
||||
BLI_testextensie(name, ".png") ||
|
||||
BLI_testextensie(name, ".bmp") ||
|
||||
|
||||
@ -46,7 +46,7 @@ struct StrandShadeCache;
|
||||
void fillrect(int *rect, int x, int y, int val);
|
||||
|
||||
/**
|
||||
* Converts a world coordinate into a homogenous coordinate in view
|
||||
* Converts a world coordinate into a homogeneous coordinate in view
|
||||
* coordinates.
|
||||
*/
|
||||
void projectvert(const float v1[3], float winmat[][4], float adr[4]);
|
||||
@ -95,7 +95,7 @@ typedef struct ZSpan {
|
||||
|
||||
float zmulx, zmuly, zofsx, zofsy; /* transform from hoco to zbuf co */
|
||||
|
||||
int *rectz, *arectz; /* zbuffers, arectz is for transparant */
|
||||
int *rectz, *arectz; /* zbuffers, arectz is for transparent */
|
||||
int *rectz1; /* seconday z buffer for shadowbuffer (2nd closest z) */
|
||||
int *rectp; /* polygon index buffer */
|
||||
int *recto; /* object buffer */
|
||||
|
||||
@ -421,7 +421,7 @@ struct VBVH_optimalPackSIMD {
|
||||
}
|
||||
}
|
||||
|
||||
//Save the ways to archieve the minimum cost with a given cutsize
|
||||
/* Save the ways to archive the minimum cost with a given cutsize */
|
||||
for (int i = nchilds; i <= MAX_CUT_SIZE; i++) {
|
||||
node->cut_cost[i - 1] = cost[nchilds][i];
|
||||
if (cost[nchilds][i] < INFINITY) {
|
||||
|
||||
@ -3391,7 +3391,7 @@ static void init_render_mesh(Render *re, ObjectRen *obr, int timeoffset)
|
||||
|
||||
ma= give_render_material(re, ob, a1+1);
|
||||
|
||||
/* test for 100% transparant */
|
||||
/* test for 100% transparent */
|
||||
ok= 1;
|
||||
if (ma->alpha==0.0f && ma->spectra==0.0f && ma->filter==0.0f && (ma->mode & MA_TRANSP) && (ma->mode & MA_RAYMIRROR)==0) {
|
||||
ok= 0;
|
||||
@ -5495,7 +5495,7 @@ static int load_fluidsimspeedvectors(Render *re, ObjectInstanceRen *obi, float *
|
||||
camco[1] = dot_v3v3(imat[1], fsvec);
|
||||
camco[2] = dot_v3v3(imat[2], fsvec);
|
||||
|
||||
/* get homogenous coordinates */
|
||||
/* get homogeneous coordinates */
|
||||
projectvert(camco, winmat, hoco);
|
||||
projectvert(ver->co, winmat, ho);
|
||||
|
||||
|
||||
@ -539,7 +539,7 @@ static void boxsample(ImBuf *ibuf, float minx, float miny, float maxx, float max
|
||||
*/
|
||||
/* note: actually minx etc isn't in the proper range... this due to filter size and offset vectors for bump */
|
||||
/* note: talpha must be initialized */
|
||||
/* note: even when 'imaprepeat' is set, this can only repeate once in any direction.
|
||||
/* note: even when 'imaprepeat' is set, this can only repeat once in any direction.
|
||||
* the point which min/max is derived from is assumed to be wrapped */
|
||||
TexResult texr;
|
||||
rctf *rf, stack[8];
|
||||
|
||||
@ -1043,7 +1043,7 @@ static void QMC_initPixel(QMCSampler *qsa, int thread)
|
||||
}
|
||||
else { /* SAMP_TYPE_HALTON */
|
||||
|
||||
/* generate a new randomised halton sequence per pixel
|
||||
/* generate a new randomized halton sequence per pixel
|
||||
* to alleviate qmc artifacts and make it reproducible
|
||||
* between threads/frames */
|
||||
double ht_invprimes[2], ht_nums[2];
|
||||
|
||||
@ -2985,7 +2985,7 @@ void do_sky_tex(const float rco[3], float lo[3], const float dxyview[2], float h
|
||||
}
|
||||
else {
|
||||
/* this value has no angle, the vector is directly along the view.
|
||||
* avoide divide by zero and use a dummy value. */
|
||||
* avoid divide by zero and use a dummy value. */
|
||||
tempvec[0]= 1.0f;
|
||||
tempvec[1]= 0.0;
|
||||
tempvec[2]= 0.0;
|
||||
|
||||
@ -49,7 +49,7 @@
|
||||
* - If the entry has no block allocated for it yet, memory is
|
||||
* allocated.
|
||||
*
|
||||
* The pointer to the correct entry is returned. Memory is guarateed
|
||||
* The pointer to the correct entry is returned. Memory is guaranteed
|
||||
* to exist (as long as the malloc does not break). Since guarded
|
||||
* allocation is used, memory _must_ be available. Otherwise, an
|
||||
* exit(0) would occur.
|
||||
|
||||
@ -360,7 +360,7 @@ static void ComputeAttenuatedSunlight(float theta, int turbidity, float fTau[3])
|
||||
* rayf, Rayleigh scattering factor, this factor currently call with 1.0
|
||||
* inscattf, inscatter light factor that range from 0.0 to 1.0, 0.0 means no inscatter light and 1.0 means full inscatter light
|
||||
* extincf, extinction light factor that range from 0.0 to 1.0, 0.0 means no extinction and 1.0 means full extinction
|
||||
* disf, is distance factor, multiplyed to pixle's z value to compute each pixle's distance to camera,
|
||||
* disf, is distance factor, multiplied to pixle's z value to compute each pixle's distance to camera,
|
||||
* */
|
||||
void InitAtmosphere(struct SunSky *sunSky, float sun_intens, float mief, float rayf,
|
||||
float inscattf, float extincf, float disf)
|
||||
|
||||
@ -415,7 +415,7 @@ static void vol_get_transmittance_seg(ShadeInput *shi, float tr[3], float stepsi
|
||||
|
||||
vol_get_sigma_t(shi, sigma_t, co);
|
||||
|
||||
/* homogenous volume within the sampled distance */
|
||||
/* homogeneous volume within the sampled distance */
|
||||
tau[0] += stepd * sigma_t[0];
|
||||
tau[1] += stepd * sigma_t[1];
|
||||
tau[2] += stepd * sigma_t[2];
|
||||
|
||||
@ -1626,7 +1626,7 @@ static void clippyra(float *labda, float *v1, float *v2, int *b2, int *b3, int a
|
||||
v13= clipcrop*v1[3];
|
||||
}
|
||||
/* according the original article by Liang&Barsky, for clipping of
|
||||
* homogenous coordinates with viewplane, the value of "0" is used instead of "-w" .
|
||||
* homogeneous coordinates with viewplane, the value of "0" is used instead of "-w" .
|
||||
* This differs from the other clipping cases (like left or top) and I considered
|
||||
* it to be not so 'homogenic'. But later it has proven to be an error,
|
||||
* who would have thought that of L&B!
|
||||
|
||||
@ -628,7 +628,7 @@ int WM_operator_call(bContext *C, wmOperator *op)
|
||||
|
||||
/* this is intended to be used when an invoke operator wants to call exec on its self
|
||||
* and is basically like running op->type->exec() directly, no poll checks no freeing,
|
||||
* since we assume whoever called invokle will take care of that */
|
||||
* since we assume whoever called invoke will take care of that */
|
||||
int WM_operator_call_notest(bContext *C, wmOperator *op)
|
||||
{
|
||||
return wm_operator_exec_notest(C, op);
|
||||
|
||||
@ -65,7 +65,7 @@ class SCA_KeyboardSensor : public SCA_ISensor
|
||||
STR_String m_targetprop;
|
||||
/**
|
||||
* The property that indicates whether or not to log text when in
|
||||
* loggin mode. If the property equals 0, no loggin is done. For
|
||||
* logging mode. If the property equals 0, no logging is done. For
|
||||
* all other values, logging is active. Logging can only become
|
||||
* active if there is a property to log to. Logging is independent
|
||||
* from hotkey settings. */
|
||||
|
||||
Loading…
Reference in New Issue
Block a user