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();
__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);
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
{
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) {
//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)
/*
* 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;
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:
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
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)
#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... */
/* 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));
}
/* 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;
unsigned int i;
MaskRasterLayer *layer = mr_handle->layers;
- /* raycast vars */
for (i = 0; i < layers_tot; i++, layer++) {
if (layer->face_array) {
}
}
-/* 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.
*
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);
/* 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);
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)
{
* - 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 ..
*/
/* 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);
/* 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) {
* **********************************************************************
* build_seqar
* *********************************************************************
- * Build a complete array of _all_ sequencies (including those
+ * Build a complete array of _all_ sequences (including those
* in metastrips!)
* *********************************************************************
*/
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;
/* 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 */
* 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.
* 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)
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;
{
/* 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;
/*
* 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;
/* - 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;
}
/* 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])
}
}
- /* lines are colliniar */
+ /* lines are collinear */
return -1;
}
}
/*
- * -1: colliniar
+ * -1: collinear
* 1: intersection
*/
static short IsectLLPt2Df(const float x0, const float y0, const float x1, const float y1,
* 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
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];
}
/* 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])
* 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.
*
* 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, ...)
{
}
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
//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) {
* 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
* \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)
{
/* 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]) {
/* 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,
}
}
/* 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)))
*
* 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)
*
* 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)
/**
* \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
/**
* \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
/**
* \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
* 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.
*/
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);
}
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);
}
}
/* 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);
}
}
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 {
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)) {
/*
* 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
*/
}
/* 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);
}
* @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.
* @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.
* 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)
* @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
* @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>
* @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
/**
* @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;
/**
* @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;
/**
* @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.
* @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
/**
- * @brief region of this buffer inside reative to the MemoryProxy
+ * @brief region of this buffer inside relative to the MemoryProxy
*/
rcti m_rect;
int getHeight() const;
/**
- * @brief clear the buffer. Make all pixels black transparant.
+ * @brief clear the buffer. Make all pixels black transparent.
*/
void clear();
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);
/**
* @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
/**
* @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
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;
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)
* 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
*
/*
* 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.
*/
/*
#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:
// *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;
}
// *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 */
* 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)
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;
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;
}
}
- /* 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;
{
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);
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);
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);
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]];
#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 */
*
*/
-/* imageprocess.c MIXED MODEL
- *
- * april 95
- *
- */
-
#include <stdlib.h>
#include "BLI_utildefines.h"
/*
* 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;
/*
* 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.
*
* 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)
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;
}
/* 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 */
/* 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 */
* - 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
*
* - 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
/* 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
*/
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),
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); */
#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) {
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;
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;
}
/**
- * 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)
{
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;
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)
* 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
*
/*
* 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.
*/
/*
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.
*/
".. 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"
".. 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"
* 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.
*
* 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.
*/
}
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;
}
}
-#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) {
/* 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, ...)
#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();
} (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, \
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.
*/
/* 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.
*/
}
//------------------------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;
/* ----------------------------------------------------------------------------
- * special type for alaternate access */
+ * special type for alternate access */
typedef struct {
PyObject_HEAD /* required python macro */
/*------------------------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;
}
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;
}
}
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;
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
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") ||
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]);
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 */
}
}
- //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) {
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;
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);
*/
/* 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];
}
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];
}
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;
* - 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.
* 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)
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];
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!
/* 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);
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. */
projects / blender-staging.git / commitdiff