forked from bartvdbraak/blender
Spelling: It's Versus Its
Corrects incorrect usage of contraction for 'it is', when possessive 'its' was required. Differential Revision: https://developer.blender.org/D9250 Reviewed by Campbell Barton
This commit is contained in:
parent
d2bf71b412
commit
3a7fd309fc
@ -57,7 +57,7 @@
|
||||
#if defined(__arm__)
|
||||
/* Attempt to fix compilation error on Debian armel kernel.
|
||||
* arm7 architecture does have both 32 and 64bit atomics, however
|
||||
* it's gcc doesn't have __GCC_HAVE_SYNC_COMPARE_AND_SWAP_n defined.
|
||||
* its gcc doesn't have __GCC_HAVE_SYNC_COMPARE_AND_SWAP_n defined.
|
||||
*/
|
||||
# define JE_FORCE_SYNC_COMPARE_AND_SWAP_1
|
||||
# define JE_FORCE_SYNC_COMPARE_AND_SWAP_4
|
||||
|
@ -105,7 +105,7 @@ class BVHSpatialSplit {
|
||||
/* Lower-level functions which calculates boundaries of left and right nodes
|
||||
* needed for spatial split.
|
||||
*
|
||||
* Operates directly with primitive specified by it's index, reused by higher
|
||||
* Operates directly with primitive specified by its index, reused by higher
|
||||
* level splitting functions.
|
||||
*/
|
||||
void split_triangle_primitive(const Mesh *mesh,
|
||||
|
@ -777,7 +777,7 @@ ccl_device void kernel_volume_decoupled_record(KernelGlobals *kg,
|
||||
*
|
||||
* This gives us restrictions that decoupled record should only happen
|
||||
* in the stack manner, meaning if there's subsequent call of decoupled
|
||||
* record it'll need to free memory before it's caller frees memory.
|
||||
* record it'll need to free memory before its caller frees memory.
|
||||
*/
|
||||
const int index = kg->decoupled_volume_steps_index;
|
||||
assert(index < sizeof(kg->decoupled_volume_steps) / sizeof(*kg->decoupled_volume_steps));
|
||||
|
@ -20,7 +20,7 @@
|
||||
/* Shader Virtual Machine
|
||||
*
|
||||
* A shader is a list of nodes to be executed. These are simply read one after
|
||||
* the other and executed, using an node counter. Each node and it's associated
|
||||
* the other and executed, using an node counter. Each node and its associated
|
||||
* data is encoded as one or more uint4's in a 1D texture. If the data is larger
|
||||
* than an uint4, the node can increase the node counter to compensate for this.
|
||||
* Floats are encoded as int and then converted to float again.
|
||||
|
@ -158,7 +158,7 @@ class TileManager {
|
||||
*
|
||||
* however viewport rendering expects tiles to be allocated in a special way,
|
||||
* meaning image is being sliced horizontally first and every device handles
|
||||
* it's own slice
|
||||
* its own slice
|
||||
*/
|
||||
bool background;
|
||||
|
||||
|
@ -141,7 +141,7 @@ ccl_device_inline float4 half4_to_float4(half4 h)
|
||||
ccl_device_inline half float_to_half(float f)
|
||||
{
|
||||
const uint u = __float_as_uint(f);
|
||||
/* Sign bit, shifted to it's position. */
|
||||
/* Sign bit, shifted to its position. */
|
||||
uint sign_bit = u & 0x80000000;
|
||||
sign_bit >>= 16;
|
||||
/* Exponent. */
|
||||
|
@ -51,7 +51,7 @@ class GHOST_IEventConsumer;
|
||||
* Blender.
|
||||
* <br><br>
|
||||
* Enough history. What does GHOST have to offer?<br>
|
||||
* In short: everything that Blender needed from GLUT to run on all it's supported
|
||||
* In short: everything that Blender needed from GLUT to run on all its supported
|
||||
* operating systems and some extra's.
|
||||
* This includes :
|
||||
*
|
||||
|
@ -60,7 +60,7 @@ class IK_QJacobian {
|
||||
int m_dof, m_task_size;
|
||||
bool m_transpose;
|
||||
|
||||
// the jacobian matrix and it's null space projector
|
||||
// the jacobian matrix and its null space projector
|
||||
MatrixXd m_jacobian, m_jacobian_tmp;
|
||||
MatrixXd m_nullspace;
|
||||
|
||||
|
@ -228,7 +228,7 @@ void NormalizedToImageSpace(const T* const intrinsics_block,
|
||||
}
|
||||
|
||||
// Cost functor which computes reprojection error of 3D point X on camera
|
||||
// defined by angle-axis rotation and it's translation (which are in the same
|
||||
// defined by angle-axis rotation and its translation (which are in the same
|
||||
// block due to optimization reasons).
|
||||
//
|
||||
// This functor can only be used for distortion models which have analytically
|
||||
@ -287,7 +287,7 @@ struct ReprojectionErrorApplyIntrinsics {
|
||||
};
|
||||
|
||||
// Cost functor which computes reprojection error of 3D point X on camera
|
||||
// defined by angle-axis rotation and it's translation (which are in the same
|
||||
// defined by angle-axis rotation and its translation (which are in the same
|
||||
// block due to optimization reasons).
|
||||
//
|
||||
// This functor can only be used for distortion models which have analytically
|
||||
|
@ -240,7 +240,7 @@ void ModalSolver(const Tracks &tracks,
|
||||
|
||||
if (marker.image == image) {
|
||||
// New track appeared on this image,
|
||||
// project it's position onto sphere.
|
||||
// project its position onto sphere.
|
||||
|
||||
LG << "Projecting track " << track << " at image " << image;
|
||||
|
||||
|
@ -1076,7 +1076,7 @@ static tbool AssignRecur(const int piTriListIn[],
|
||||
return TFALSE;
|
||||
if ((pMyTriInfo->iFlag & GROUP_WITH_ANY) != 0) {
|
||||
// first to group with a group-with-anything triangle
|
||||
// determines it's orientation.
|
||||
// determines its orientation.
|
||||
// This is the only existing order dependency in the code!!
|
||||
if (pMyTriInfo->AssignedGroup[0] == NULL && pMyTriInfo->AssignedGroup[1] == NULL &&
|
||||
pMyTriInfo->AssignedGroup[2] == NULL) {
|
||||
|
@ -471,7 +471,7 @@ bool OCIOImpl::supportGLSLDraw()
|
||||
* using regular 2D texture.
|
||||
*
|
||||
* When all drawing is finished, finishGLSLDraw shall be called to
|
||||
* restore OpenGL context to it's pre-GLSL draw state.
|
||||
* restore OpenGL context to its pre-GLSL draw state.
|
||||
*/
|
||||
bool OCIOImpl::setupGLSLDraw(OCIO_GLSLDrawState **state_r,
|
||||
OCIO_ConstProcessorRcPtr *ocio_processor_scene_to_ui,
|
||||
|
@ -250,7 +250,7 @@ inline bool TopologyRefinerFactory<TopologyRefinerData>::assignComponentTags(
|
||||
base_mesh_topology->setVertexSharpness(vertex_index, sharpness);
|
||||
}
|
||||
|
||||
// If it's vertex where 2 non-manifold edges meet adjust vertex sharpness to
|
||||
// If its vertex where 2 non-manifold edges meet adjust vertex sharpness to
|
||||
// the edges.
|
||||
// This way having a plane with all 4 edges set to be sharp produces sharp
|
||||
// corners in the subdivided result.
|
||||
|
@ -107,7 +107,7 @@ typedef struct OpenSubdiv_Converter {
|
||||
bool (*isInfiniteSharpVertex)(const struct OpenSubdiv_Converter *converter,
|
||||
const int vertex_index);
|
||||
|
||||
// If vertex is not infinitely sharp, this is it's actual sharpness.
|
||||
// If vertex is not infinitely sharp, this is its actual sharpness.
|
||||
float (*getVertexSharpness)(const struct OpenSubdiv_Converter *converter,
|
||||
const int vertex_index);
|
||||
|
||||
|
@ -38,7 +38,7 @@
|
||||
* per-element attributes and interpolate them (e.g. uvs, vcols, vgroups, etc).
|
||||
*
|
||||
* Mesh is the "serialized" structure, used for storing object-mode mesh data
|
||||
* and also for saving stuff to disk. It's interfaces are also what DerivedMesh
|
||||
* and also for saving stuff to disk. Its interfaces are also what DerivedMesh
|
||||
* uses to communicate with.
|
||||
*
|
||||
* CDDM is a little mesh library, that uses Mesh data structures in the backend.
|
||||
|
@ -174,7 +174,7 @@ typedef struct AnimationBasePathChange {
|
||||
const char *dst_basepath;
|
||||
} AnimationBasePathChange;
|
||||
|
||||
/* Move animation data from src to destination if it's paths are based on basepaths */
|
||||
/* Move animation data from src to destination if its paths are based on basepaths */
|
||||
void BKE_animdata_transfer_by_basepath(struct Main *bmain,
|
||||
struct ID *srcID,
|
||||
struct ID *dstID,
|
||||
|
@ -45,7 +45,7 @@ struct Scene;
|
||||
* This structure is used for mesh edit-mode.
|
||||
*
|
||||
* through this, you get access to both the edit #BMesh,
|
||||
* it's tessellation, and various stuff that doesn't belong in the BMesh
|
||||
* its tessellation, and various stuff that doesn't belong in the BMesh
|
||||
* struct itself.
|
||||
*
|
||||
* the entire derivedmesh and modifier system works with this structure,
|
||||
|
@ -94,7 +94,7 @@ typedef struct Main {
|
||||
/** All current ID's exist in the last memfile undo step. */
|
||||
char is_memfile_undo_written;
|
||||
/**
|
||||
* An ID needs it's data to be flushed back.
|
||||
* An ID needs its data to be flushed back.
|
||||
* use "needs_flush_to_id" in edit data to flag data which needs updating.
|
||||
*/
|
||||
char is_memfile_undo_flush_needed;
|
||||
|
@ -768,7 +768,7 @@ const char *BKE_pose_ikparam_get_name(bPose *pose)
|
||||
}
|
||||
|
||||
/**
|
||||
* Allocate a new pose on the heap, and copy the src pose and it's channels
|
||||
* Allocate a new pose on the heap, and copy the src pose and its channels
|
||||
* into the new pose. *dst is set to the newly allocated structure, and assumed to be NULL.
|
||||
*
|
||||
* \param dst: Should be freed already, makes entire duplicate.
|
||||
@ -1813,7 +1813,7 @@ void what_does_obaction(Object *ob,
|
||||
adt.action = act;
|
||||
BKE_animdata_action_ensure_idroot(&workob->id, act);
|
||||
|
||||
/* execute effects of Action on to workob (or it's PoseChannels) */
|
||||
/* execute effects of Action on to workob (or its PoseChannels) */
|
||||
BKE_animsys_evaluate_animdata(&workob->id, &adt, anim_eval_context, ADT_RECALC_ANIM, false);
|
||||
}
|
||||
}
|
||||
|
@ -1957,7 +1957,7 @@ static void nlastrip_evaluate_meta(PointerRNA *ptr,
|
||||
|
||||
/* meta-strip was calculated normally to have some time to be evaluated at
|
||||
* and here we 'look inside' the meta strip, treating it as a decorated window to
|
||||
* it's child strips, which get evaluated as if they were some tracks on a strip
|
||||
* its child strips, which get evaluated as if they were some tracks on a strip
|
||||
* (but with some extra modifiers to apply).
|
||||
*
|
||||
* NOTE: keep this in sync with animsys_evaluate_nla()
|
||||
|
@ -169,7 +169,7 @@ bMotionPath *animviz_verify_motionpaths(ReportList *reports,
|
||||
}
|
||||
|
||||
/* if there is already a motionpath, just return that,
|
||||
* provided it's settings are ok (saves extra free+alloc)
|
||||
* provided its settings are ok (saves extra free+alloc)
|
||||
*/
|
||||
if (*dst != NULL) {
|
||||
int expected_length = avs->path_ef - avs->path_sf;
|
||||
|
@ -407,7 +407,7 @@ static void copy_bonechildren(Bone *bone_dst,
|
||||
/* Copy this bone's list */
|
||||
BLI_duplicatelist(&bone_dst->childbase, &bone_src->childbase);
|
||||
|
||||
/* For each child in the list, update it's children */
|
||||
/* For each child in the list, update its children */
|
||||
for (bone_src_child = bone_src->childbase.first, bone_dst_child = bone_dst->childbase.first;
|
||||
bone_src_child;
|
||||
bone_src_child = bone_src_child->next, bone_dst_child = bone_dst_child->next) {
|
||||
@ -726,7 +726,7 @@ bool bone_autoside_name(
|
||||
* - The extension to append is based upon the axis that we are working on.
|
||||
* - If head happens to be on 0, then we must consider the tail position as well to decide
|
||||
* which side the bone is on
|
||||
* -> If tail is 0, then it's bone is considered to be on axis, so no extension should be added
|
||||
* -> If tail is 0, then its bone is considered to be on axis, so no extension should be added
|
||||
* -> Otherwise, extension is added from perspective of object based on which side tail goes to
|
||||
* - If head is non-zero, extension is added from perspective of object based on side head is on
|
||||
*/
|
||||
@ -1241,7 +1241,7 @@ void BKE_pchan_bbone_handles_compute(const BBoneSplineParameters *param,
|
||||
/* Extra curve x / y */
|
||||
/* NOTE:
|
||||
* Scale correction factors here are to compensate for some random floating-point glitches
|
||||
* when scaling up the bone or it's parent by a factor of approximately 8.15/6, which results
|
||||
* when scaling up the bone or its parent by a factor of approximately 8.15/6, which results
|
||||
* in the bone length getting scaled up too (from 1 to 8), causing the curve to flatten out.
|
||||
*/
|
||||
const float xscale_correction = (param->do_scale) ? param->scale[0] : 1.0f;
|
||||
|
@ -2420,7 +2420,7 @@ static void make_bevel_list_3D_minimum_twist(BevList *bl)
|
||||
else {
|
||||
/* Need to correct quat for the first/last point,
|
||||
* this is so because previously it was only calculated
|
||||
* using it's own direction, which might not correspond
|
||||
* using its own direction, which might not correspond
|
||||
* the twist of neighbor point.
|
||||
*/
|
||||
bevp1 = bl->bevpoints;
|
||||
@ -4606,7 +4606,7 @@ void BKE_nurb_direction_switch(Nurb *nu)
|
||||
bp2--;
|
||||
}
|
||||
/* If there are odd number of points no need to touch coord of middle one,
|
||||
* but still need to change it's tilt.
|
||||
* but still need to change its tilt.
|
||||
*/
|
||||
if (nu->pntsu & 1) {
|
||||
bp1->tilt = -bp1->tilt;
|
||||
|
@ -231,7 +231,7 @@ typedef struct PaintUVPoint {
|
||||
/* vertex indexes */
|
||||
unsigned int v1, v2, v3;
|
||||
|
||||
/** If this pixel isn't uv mapped to any face, but it's neighboring pixel is. */
|
||||
/** If this pixel isn't uv mapped to any face, but its neighboring pixel is. */
|
||||
unsigned int neighbor_pixel;
|
||||
} PaintUVPoint;
|
||||
|
||||
@ -2688,7 +2688,7 @@ static void dynamic_paint_find_island_border(const DynamicPaintCreateUVSurfaceDa
|
||||
continue;
|
||||
}
|
||||
|
||||
/* If final point is an "edge pixel", use it's "real" neighbor instead */
|
||||
/* If final point is an "edge pixel", use its "real" neighbor instead */
|
||||
if (tempPoints[final_index].neighbor_pixel != -1) {
|
||||
final_index = tempPoints[final_index].neighbor_pixel;
|
||||
|
||||
@ -6271,7 +6271,7 @@ static int dynamicPaint_doStep(Depsgraph *depsgraph,
|
||||
eModifierType_DynamicPaint);
|
||||
}
|
||||
|
||||
/* Apply brush on the surface depending on it's collision type */
|
||||
/* Apply brush on the surface depending on its collision type */
|
||||
if (brush->psys && brush->psys->part &&
|
||||
ELEM(brush->psys->part->type,
|
||||
PART_EMITTER,
|
||||
@ -6299,7 +6299,7 @@ static int dynamicPaint_doStep(Depsgraph *depsgraph,
|
||||
dynamicPaint_paintMesh(depsgraph, surface, brush, brushObj, scene, timescale);
|
||||
}
|
||||
|
||||
/* reset object to it's original state */
|
||||
/* reset object to its original state */
|
||||
if (subframe) {
|
||||
scene->r.cfra = scene_frame;
|
||||
scene->r.subframe = scene_subframe;
|
||||
|
@ -79,7 +79,7 @@ static size_t idp_size_table[] = {
|
||||
|
||||
/**
|
||||
* \note as a start to move away from the stupid IDP_New function, this type
|
||||
* has it's own allocation function.
|
||||
* has its own allocation function.
|
||||
*/
|
||||
IDProperty *IDP_NewIDPArray(const char *name)
|
||||
{
|
||||
@ -959,7 +959,7 @@ bool IDP_EqualsProperties(IDProperty *prop1, IDProperty *prop2)
|
||||
* Allocate a new ID.
|
||||
*
|
||||
* This function takes three arguments: the ID property type, a union which defines
|
||||
* it's initial value, and a name.
|
||||
* its initial value, and a name.
|
||||
*
|
||||
* The union is simple to use; see the top of this header file for its definition.
|
||||
* An example of using this function:
|
||||
|
@ -547,7 +547,7 @@ static Image *image_alloc(Main *bmain, const char *name, short source, short typ
|
||||
return ima;
|
||||
}
|
||||
|
||||
/* Get the ibuf from an image cache by it's index and entry.
|
||||
/* Get the ibuf from an image cache by its index and entry.
|
||||
* Local use here only.
|
||||
*
|
||||
* Returns referenced image buffer if it exists, callee is to
|
||||
|
@ -48,7 +48,7 @@
|
||||
* \{ */
|
||||
|
||||
struct IDNameLib_Key {
|
||||
/** ``ID.name + 2``: without the ID type prefix, since each id type gets it's own 'map' */
|
||||
/** ``ID.name + 2``: without the ID type prefix, since each id type gets its own 'map' */
|
||||
const char *name;
|
||||
/** ``ID.lib``: */
|
||||
const Library *lib;
|
||||
|
@ -975,7 +975,7 @@ void BKE_object_free_caches(Object *object)
|
||||
}
|
||||
|
||||
/* Tag object for update, so once memory critical operation is over and
|
||||
* scene update routines are back to it's business the object will be
|
||||
* scene update routines are back to its business the object will be
|
||||
* guaranteed to be in a known state.
|
||||
*/
|
||||
if (update_flag != 0) {
|
||||
@ -2800,7 +2800,7 @@ void BKE_object_where_is_calc_time(Depsgraph *depsgraph, Scene *scene, Object *o
|
||||
/**
|
||||
* Calculate object transformation matrix without recalculating dependencies and
|
||||
* constraints -- assume dependencies are already solved by depsgraph.
|
||||
* No changes to object and it's parent would be done.
|
||||
* No changes to object and its parent would be done.
|
||||
* Used for bundles orientation in 3d space relative to parented blender camera.
|
||||
*/
|
||||
void BKE_object_where_is_calc_mat4(Object *ob, float r_obmat[4][4])
|
||||
|
@ -1107,7 +1107,7 @@ static void pbvh_faces_update_normals(PBVH *pbvh, PBVHNode **nodes, int totnode)
|
||||
* - We know that for all edited vertices, the nodes with faces
|
||||
* adjacent to these vertices have been marked with PBVH_UpdateNormals.
|
||||
* This is true because if the vertex is inside the brush radius, the
|
||||
* bounding box of it's adjacent faces will be as well.
|
||||
* bounding box of its adjacent faces will be as well.
|
||||
* - However this is only true for the vertices that have actually been
|
||||
* edited, not for all vertices in the nodes marked for update, so we
|
||||
* can only update vertices marked with ME_VERT_PBVH_UPDATE.
|
||||
|
@ -229,7 +229,7 @@ BLI_INLINE void sound_verify_evaluated_id(const ID *id)
|
||||
*
|
||||
* Data-blocks which are covered by a copy-on-write system of dependency graph will have
|
||||
* LIB_TAG_COPIED_ON_WRITE tag set on them. But if some of data-blocks during its evaluation
|
||||
* decides to re-allocate it's nested one (for example, object evaluation could re-allocate mesh
|
||||
* decides to re-allocate its nested one (for example, object evaluation could re-allocate mesh
|
||||
* when evaluating modifier stack). Such data-blocks will have
|
||||
* LIB_TAG_COPIED_ON_WRITE_EVAL_RESULT tag set on them.
|
||||
*
|
||||
|
@ -1492,7 +1492,7 @@ MovieTrackingPlaneTrack *BKE_tracking_plane_track_add(MovieTracking *tracking,
|
||||
|
||||
BKE_tracking_plane_marker_insert(plane_track, &plane_marker);
|
||||
|
||||
/* Put new plane track to the list, ensure it's name is unique. */
|
||||
/* Put new plane track to the list, ensure its name is unique. */
|
||||
BLI_addtail(plane_tracks_base, plane_track);
|
||||
BKE_tracking_plane_track_unique_name(plane_tracks_base, plane_track);
|
||||
|
||||
|
@ -774,7 +774,7 @@ bool BLI_ghash_reinsert(
|
||||
/**
|
||||
* Replaces the key of an item in the \a gh.
|
||||
*
|
||||
* Use when a key is re-allocated or it's memory location is changed.
|
||||
* Use when a key is re-allocated or its memory location is changed.
|
||||
*
|
||||
* \returns The previous key or NULL if not found, the caller may free if it's needed.
|
||||
*/
|
||||
|
@ -21,7 +21,7 @@
|
||||
* \ingroup bli
|
||||
*
|
||||
* Helper functions and implementations of standard data types for #GHash
|
||||
* (not it's implementation).
|
||||
* (not its implementation).
|
||||
*/
|
||||
|
||||
#include <string.h>
|
||||
|
@ -330,7 +330,7 @@ float BLI_heap_top_value(const Heap *heap)
|
||||
}
|
||||
|
||||
/**
|
||||
* Pop the top node off the heap and return it's pointer.
|
||||
* Pop the top node off the heap and return its pointer.
|
||||
*/
|
||||
void *BLI_heap_pop_min(Heap *heap)
|
||||
{
|
||||
|
@ -225,7 +225,7 @@ float BLI_heapsimple_top_value(const HeapSimple *heap)
|
||||
}
|
||||
|
||||
/**
|
||||
* Pop the top node off the heap and return it's pointer.
|
||||
* Pop the top node off the heap and return its pointer.
|
||||
*/
|
||||
void *BLI_heapsimple_pop_min(HeapSimple *heap)
|
||||
{
|
||||
|
@ -878,7 +878,7 @@ static void deduplicate_recursive(const struct DeDuplicateParams *p, uint i)
|
||||
* the iteration order.
|
||||
* \param duplicates: An array of int's the length of #KDTree.nodes_len
|
||||
* Values initialized to -1 are candidates to me merged.
|
||||
* Setting the index to it's own position in the array prevents it from being touched,
|
||||
* Setting the index to its own position in the array prevents it from being touched,
|
||||
* although it can still be used as a target.
|
||||
* \returns The number of merges found (includes any merges already in the \a duplicates array).
|
||||
*
|
||||
|
@ -432,7 +432,7 @@ void BLI_insertlinkbefore(ListBase *listbase, void *vnextlink, void *vnewlink)
|
||||
}
|
||||
|
||||
/**
|
||||
* Insert a link in place of another, without changing it's position in the list.
|
||||
* Insert a link in place of another, without changing its position in the list.
|
||||
*
|
||||
* Puts `vnewlink` in the position of `vreplacelink`, removing `vreplacelink`.
|
||||
* - `vreplacelink` *must* be in the list.
|
||||
|
@ -4474,7 +4474,7 @@ void interp_cubic_v3(float x[3],
|
||||
*
|
||||
* Compute coordinates (u, v) for point \a st with respect to triangle (\a st0, \a st1, \a st2)
|
||||
*
|
||||
* \note same basic result as #barycentric_weights_v2, see it's comment for details.
|
||||
* \note same basic result as #barycentric_weights_v2, see its comment for details.
|
||||
*/
|
||||
void resolve_tri_uv_v2(
|
||||
float r_uv[2], const float st[2], const float st0[2], const float st1[2], const float st2[2])
|
||||
|
@ -4495,7 +4495,7 @@ static void lib_link_scene(BlendLibReader *reader, Scene *sce)
|
||||
}
|
||||
}
|
||||
|
||||
/* rigidbody world relies on it's linked collections */
|
||||
/* rigidbody world relies on its linked collections */
|
||||
if (sce->rigidbody_world) {
|
||||
RigidBodyWorld *rbw = sce->rigidbody_world;
|
||||
if (rbw->group) {
|
||||
|
@ -615,7 +615,7 @@ void BLO_update_defaults_startup_blend(Main *bmain, const char *app_template)
|
||||
* when painting we want to use full color/weight always.
|
||||
*
|
||||
* Note that sculpt is an exception,
|
||||
* it's values are overwritten by #BKE_brush_sculpt_reset below. */
|
||||
* its values are overwritten by #BKE_brush_sculpt_reset below. */
|
||||
brush->alpha = 1.0;
|
||||
|
||||
/* Enable antialiasing by default */
|
||||
|
@ -120,7 +120,7 @@
|
||||
* which are private to an operator.
|
||||
* These flags may be used by the client operator code as needed
|
||||
* (a common example is flagging elements for use in another operator).
|
||||
* Each call to an operator allocates it's own set of tool flags when it's executed,
|
||||
* Each call to an operator allocates its own set of tool flags when it's executed,
|
||||
* avoiding flag conflicts between operators.
|
||||
*
|
||||
* These flags should not be confused with header flags, which are used to store persistent flags
|
||||
|
@ -99,7 +99,7 @@ static void bm_loop_attrs_copy(
|
||||
* If \a no_double is true, then a check is done to see if a face
|
||||
* with these vertices already exists and returns it instead.
|
||||
*
|
||||
* If a pointer to an example face is provided, it's custom data
|
||||
* If a pointer to an example face is provided, its custom data
|
||||
* and properties will be copied to the new face.
|
||||
*
|
||||
* \note The winding of the face is determined by the order
|
||||
|
@ -815,7 +815,7 @@ void BM_log_redo(BMesh *bm, BMLog *log)
|
||||
/* Log a vertex before it is modified
|
||||
*
|
||||
* Before modifying vertex coordinates, masks, or hflags, call this
|
||||
* function to log it's current values. This is better than logging
|
||||
* function to log its current values. This is better than logging
|
||||
* after the coordinates have been modified, because only those
|
||||
* vertices that are modified need to have their original values
|
||||
* stored.
|
||||
|
@ -368,7 +368,7 @@ void _bmo_slot_copy(BMOpSlot slot_args_src[BMO_OP_MAX_SLOTS],
|
||||
/*
|
||||
* BMESH OPSTACK SET XXX
|
||||
*
|
||||
* Sets the value of a slot depending on it's type
|
||||
* Sets the value of a slot depending on its type
|
||||
*/
|
||||
|
||||
void BMO_slot_float_set(BMOpSlot slot_args[BMO_OP_MAX_SLOTS], const char *slot_name, const float f)
|
||||
|
@ -667,7 +667,7 @@ void BM_face_calc_center_median_weighted(const BMFace *f, float r_cent[3])
|
||||
/**
|
||||
* \brief POLY ROTATE PLANE
|
||||
*
|
||||
* Rotates a polygon so that it's
|
||||
* Rotates a polygon so that its
|
||||
* normal is pointing towards the mesh Z axis
|
||||
*/
|
||||
void poly_rotate_plane(const float normal[3], float (*verts)[3], const uint nverts)
|
||||
@ -889,7 +889,7 @@ float BM_face_calc_normal_vcos(const BMesh *bm,
|
||||
* Calculate a normal from a vertex cloud.
|
||||
*
|
||||
* \note We could make a higher quality version that takes all vertices into account.
|
||||
* Currently it finds 4 outer most points returning it's normal.
|
||||
* Currently it finds 4 outer most points returning its normal.
|
||||
*/
|
||||
void BM_verts_calc_normal_from_cloud_ex(
|
||||
BMVert **varr, int varr_len, float r_normal[3], float r_center[3], int *r_index_tangent)
|
||||
|
@ -521,7 +521,7 @@ bool BM_face_split_edgenet(BMesh *bm,
|
||||
|
||||
/* Note: 'VERT_IN_QUEUE' is often not needed at all,
|
||||
* however in rare cases verts are added multiple times to the queue,
|
||||
* that on it's own is harmless but in _very_ rare cases,
|
||||
* that on its own is harmless but in _very_ rare cases,
|
||||
* the queue will overflow its maximum size,
|
||||
* so we better be strict about this! see: T51539 */
|
||||
|
||||
|
@ -39,7 +39,7 @@
|
||||
* to implement recursive or looping behavior. generally only one
|
||||
* state push per call with a specific state is desired.
|
||||
*
|
||||
* basic design pattern: the walker step function goes through it's
|
||||
* basic design pattern: the walker step function goes through its
|
||||
* list of possible choices for recursion, and recurses (by pushing a new state)
|
||||
* using the first non-visited one. This choice is the flagged as visited using
|
||||
* the ghash. each step may push multiple new states onto the worklist at once.
|
||||
|
@ -117,7 +117,7 @@ void bmo_edgenet_prepare_exec(BMesh *bm, BMOperator *op)
|
||||
BMO_slot_buffer_flag_enable(bm, op->slots_in, "edges", BM_EDGE, EDGE_MARK);
|
||||
|
||||
/* validate that each edge has at most one other tagged edge in the
|
||||
* disk cycle around each of it's vertices */
|
||||
* disk cycle around each of its vertices */
|
||||
BMO_ITER (e, &siter, op->slots_in, "edges", BM_EDGE) {
|
||||
for (i = 0; i < 2; i++) {
|
||||
count = BMO_iter_elem_count_flag(bm, BM_EDGES_OF_VERT, (i ? e->v2 : e->v1), EDGE_MARK, true);
|
||||
|
@ -33,7 +33,7 @@
|
||||
#define FACE_MARK 1
|
||||
|
||||
/**
|
||||
* Rotate edges where every edge has it's own faces (we can rotate in any order).
|
||||
* Rotate edges where every edge has its own faces (we can rotate in any order).
|
||||
*/
|
||||
static void bm_rotate_edges_simple(BMesh *bm,
|
||||
BMOperator *op,
|
||||
|
@ -137,7 +137,7 @@ static void bm_decim_build_quadrics(BMesh *bm, Quadric *vquadrics)
|
||||
static void bm_decim_calc_target_co_db(BMEdge *e, double optimize_co[3], const Quadric *vquadrics)
|
||||
{
|
||||
/* compute an edge contraction target for edge 'e'
|
||||
* this is computed by summing it's vertices quadrics and
|
||||
* this is computed by summing its vertices quadrics and
|
||||
* optimizing the result. */
|
||||
Quadric q;
|
||||
|
||||
|
@ -1029,7 +1029,7 @@ static void do_createEdgeLocationBuffer(unsigned int t,
|
||||
/* set the accumulators to correct positions */ // set up some accumulator variables for loops
|
||||
gradientAccum = gradientFillOffset; // each accumulator variable starts at its respective
|
||||
innerAccum = *innerEdgeOffset; // section's offset so when we start filling, each
|
||||
outerAccum = *outerEdgeOffset; // section fills up it's allocated space in gbuf
|
||||
outerAccum = *outerEdgeOffset; // section fills up its allocated space in gbuf
|
||||
// uses dmin=row, rsl=col
|
||||
for (x = 0, dmin = 0; x < t; x += rw, dmin++) {
|
||||
for (rsl = 0; rsl < rw; rsl++) {
|
||||
|
@ -25,7 +25,7 @@
|
||||
|
||||
typedef float fREAL;
|
||||
|
||||
// returns next highest power of 2 of x, as well it's log2 in L2
|
||||
// returns next highest power of 2 of x, as well its log2 in L2
|
||||
static unsigned int nextPow2(unsigned int x, unsigned int *L2)
|
||||
{
|
||||
unsigned int pw, x_notpow2 = x & (x - 1);
|
||||
|
@ -2869,7 +2869,7 @@ void DepsgraphRelationBuilder::build_copy_on_write_relations(IDNode *id_node)
|
||||
/* NOTE: We currently ignore implicit relations to an external
|
||||
* data-blocks for copy-on-write operations. This means, for example,
|
||||
* copy-on-write component of Object will not wait for copy-on-write
|
||||
* component of it's Mesh. This is because pointers are all known
|
||||
* component of its Mesh. This is because pointers are all known
|
||||
* already so remapping will happen all correct. And then If some object
|
||||
* evaluation step needs geometry, it will have transitive dependency
|
||||
* to Mesh copy-on-write already. */
|
||||
|
@ -348,7 +348,7 @@ void DepsgraphRelationBuilder::build_rig(Object *object)
|
||||
// root_map.print_debug();
|
||||
if (pose_depends_on_local_transform) {
|
||||
/* TODO(sergey): Once partial updates are possible use relation between
|
||||
* object transform and solver itself in it's build function. */
|
||||
* object transform and solver itself in its build function. */
|
||||
ComponentKey pose_key(&object->id, NodeType::EVAL_POSE);
|
||||
ComponentKey local_transform_key(&object->id, NodeType::TRANSFORM);
|
||||
add_relation(local_transform_key, pose_key, "Local Transforms");
|
||||
@ -477,7 +477,7 @@ void DepsgraphRelationBuilder::build_proxy_rig(Object *object)
|
||||
add_relation(bone_ready_key, bone_done_key, "Ready -> Done");
|
||||
add_relation(bone_done_key, pose_cleanup_key, "Bone Done -> Pose Cleanup");
|
||||
add_relation(bone_done_key, pose_done_key, "Bone Done -> Pose Done", RELATION_FLAG_GODMODE);
|
||||
/* Make sure bone in the proxy is not done before it's FROM is done. */
|
||||
/* Make sure bone in the proxy is not done before its FROM is done. */
|
||||
if (check_pchan_has_bbone(object, pchan)) {
|
||||
OperationKey from_bone_segments_key(
|
||||
&proxy_from->id, NodeType::BONE, pchan->name, OperationCode::BONE_SEGMENTS);
|
||||
|
@ -766,7 +766,7 @@ void update_proxy_pointers_after_copy(const Depsgraph *depsgraph,
|
||||
}
|
||||
}
|
||||
|
||||
/* Do some special treatment of data transfer from original ID to it's
|
||||
/* Do some special treatment of data transfer from original ID to its
|
||||
* CoW complementary part.
|
||||
*
|
||||
* Only use for the newly created CoW data-blocks. */
|
||||
|
@ -299,7 +299,7 @@ Node::~Node()
|
||||
{
|
||||
/* Free links. */
|
||||
/* NOTE: We only free incoming links. This is to avoid double-free of links
|
||||
* when we're trying to free same link from both it's sides. We don't have
|
||||
* when we're trying to free same link from both its sides. We don't have
|
||||
* dangling links so this is not a problem from memory leaks point of view. */
|
||||
for (Relation *rel : inlinks) {
|
||||
delete rel;
|
||||
|
@ -140,7 +140,7 @@ void prepare_raycast(vec3 ray_origin,
|
||||
|
||||
// #define GROUPED_FETCHES /* is still slower, need to see where is the bottleneck. */
|
||||
/* Return the hit position, and negate the z component (making it positive) if not hit occurred. */
|
||||
/* __ray_dir__ is the ray direction premultiplied by it's maximum length */
|
||||
/* __ray_dir__ is the ray direction premultiplied by its maximum length */
|
||||
vec3 raycast(int index,
|
||||
vec3 ray_origin,
|
||||
vec3 ray_dir,
|
||||
|
@ -48,7 +48,7 @@ void main()
|
||||
#else /* World */
|
||||
|
||||
/* This is just a pass-through geometry shader that send the geometry
|
||||
* to the layer corresponding to it's depth. */
|
||||
* to the layer corresponding to its depth. */
|
||||
|
||||
void main()
|
||||
{
|
||||
|
@ -726,7 +726,7 @@ static void set_pchan_colorset(ArmatureDrawContext *ctx, Object *ob, bPoseChanne
|
||||
|
||||
/* only try to set custom color if enabled for armature */
|
||||
if (arm->flag & ARM_COL_CUSTOM) {
|
||||
/* currently, a bone can only use a custom color set if it's group (if it has one),
|
||||
/* currently, a bone can only use a custom color set if its group (if it has one),
|
||||
* has been set to use one
|
||||
*/
|
||||
if (pchan->agrp_index) {
|
||||
|
@ -74,7 +74,7 @@ static struct GPUTexture *create_jitter_texture(int num_samples)
|
||||
/* This rotate the sample per pixels */
|
||||
jitter[i][0] = cosf(phi);
|
||||
jitter[i][1] = sinf(phi);
|
||||
/* This offset the sample along it's direction axis (reduce banding) */
|
||||
/* This offset the sample along its direction axis (reduce banding) */
|
||||
float bn = blue_noise[i][1] - 0.5f;
|
||||
CLAMP(bn, -0.499f, 0.499f); /* fix fireflies */
|
||||
jitter[i][2] = bn * num_samples_inv;
|
||||
|
@ -293,7 +293,7 @@ DRWView *DRW_view_create_with_zoffset(const DRWView *parent_view,
|
||||
|
||||
/* TODO FINISH */
|
||||
/**
|
||||
* Get the wire color theme_id of an object based on it's state
|
||||
* Get the wire color theme_id of an object based on its state
|
||||
* \a r_color is a way to get a pointer to the static color var associated
|
||||
*/
|
||||
int DRW_object_wire_theme_get(Object *ob, ViewLayer *view_layer, float **r_color)
|
||||
|
@ -105,7 +105,7 @@ static void instancing_batch_references_remove(GPUBatch *batch)
|
||||
* This manager allows to distribute existing batches for instancing
|
||||
* attributes. This reduce the number of batches creation.
|
||||
* Querying a batch is done with a vertex format. This format should
|
||||
* be static so that it's pointer never changes (because we are using
|
||||
* be static so that its pointer never changes (because we are using
|
||||
* this pointer as identifier [we don't want to check the full format
|
||||
* that would be too slow]).
|
||||
*/
|
||||
|
@ -1397,7 +1397,7 @@ static size_t animfilter_act_group(bAnimContext *ac,
|
||||
/* Care about selection status. */
|
||||
(filter_mode & (ANIMFILTER_SEL | ANIMFILTER_UNSEL))) {
|
||||
/* If the group itself isn't selected appropriately,
|
||||
* we shouldn't consider it's children either. */
|
||||
* we shouldn't consider its children either. */
|
||||
if (ANIMCHANNEL_SELOK(SEL_AGRP(agrp)) == 0) {
|
||||
return 0;
|
||||
}
|
||||
@ -1419,7 +1419,7 @@ static size_t animfilter_act_group(bAnimContext *ac,
|
||||
/* special filter so that we can get just the F-Curves within the active group */
|
||||
if (!(filter_mode & ANIMFILTER_ACTGROUPED) || (agrp->flag & AGRP_ACTIVE)) {
|
||||
/* for the Graph Editor, curves may be set to not be visible in the view to lessen
|
||||
* clutter, but to do this, we need to check that the group doesn't have it's
|
||||
* clutter, but to do this, we need to check that the group doesn't have its
|
||||
* not-visible flag set preventing all its sub-curves to be shown
|
||||
*/
|
||||
if (!(filter_mode & ANIMFILTER_CURVE_VISIBLE) || !(agrp->flag & AGRP_NOTVISIBLE)) {
|
||||
|
@ -386,7 +386,7 @@ static void updateDuplicateSubtarget(EditBone *dup_bone,
|
||||
Object *ob,
|
||||
bool lookup_mirror_subtarget)
|
||||
{
|
||||
/* If an edit bone has been duplicated, lets update it's constraints if the
|
||||
/* If an edit bone has been duplicated, lets update its constraints if the
|
||||
* subtarget they point to has also been duplicated.
|
||||
*/
|
||||
EditBone *oldtarget, *newtarget;
|
||||
@ -812,7 +812,7 @@ static void updateDuplicateTransformConstraintSettings(Object *ob,
|
||||
|
||||
static void updateDuplicateConstraintSettings(EditBone *dup_bone, EditBone *orig_bone, Object *ob)
|
||||
{
|
||||
/* If an edit bone has been duplicated, lets update it's constraints if the
|
||||
/* If an edit bone has been duplicated, lets update its constraints if the
|
||||
* subtarget they point to has also been duplicated.
|
||||
*/
|
||||
bPoseChannel *pchan;
|
||||
|
@ -418,7 +418,7 @@ static bool armature_select_linked_impl(Object *ob, const bool select, const boo
|
||||
* Bones that have been touched are skipped, so the complexity is OK. */
|
||||
|
||||
enum {
|
||||
/* Bone has been walked over, it's LINK value can be read. */
|
||||
/* Bone has been walked over, its LINK value can be read. */
|
||||
TOUCH = (1 << 0),
|
||||
/* When TOUCH has been set, this flag can be checked to see if the bone is connected. */
|
||||
LINK = (1 << 1),
|
||||
|
@ -746,7 +746,7 @@ static int pose_copy_exec(bContext *C, wmOperator *op)
|
||||
}
|
||||
/* Sets chan->flag to POSE_KEY if bone selected. */
|
||||
set_pose_keys(ob);
|
||||
/* Construct a local bmain and only put object and it's data into it,
|
||||
/* Construct a local bmain and only put object and its data into it,
|
||||
* o this way we don't expand any other objects into the copy buffer
|
||||
* file.
|
||||
*
|
||||
@ -767,7 +767,7 @@ static int pose_copy_exec(bContext *C, wmOperator *op)
|
||||
/* begin copy buffer on a temp bmain. */
|
||||
BKE_copybuffer_begin(temp_bmain);
|
||||
/* Store the whole object to the copy buffer because pose can't be
|
||||
* existing on it's own.
|
||||
* existing on its own.
|
||||
*/
|
||||
BKE_copybuffer_tag_ID(&ob_copy.id);
|
||||
BLI_join_dirfile(str, sizeof(str), BKE_tempdir_base(), "copybuffer_pose.blend");
|
||||
|
@ -226,7 +226,7 @@ typedef enum eModifyKey_Returns {
|
||||
MODIFYKEY_MISSING_TYPEINFO = -2,
|
||||
} eModifyKey_Returns;
|
||||
|
||||
/* poll the current KeyingSet, updating it's set of paths
|
||||
/* poll the current KeyingSet, updating its set of paths
|
||||
* (if "builtin"/"relative") for context changes */
|
||||
eModifyKey_Returns ANIM_validate_keyingset(struct bContext *C,
|
||||
ListBase *dsources,
|
||||
|
@ -2879,7 +2879,7 @@ char *ui_but_string_get_dynamic(uiBut *but, int *r_str_size)
|
||||
|
||||
/**
|
||||
* Report a generic error prefix when evaluating a string with #BPY_run_string_as_number
|
||||
* as the Python error on it's own doesn't provide enough context.
|
||||
* as the Python error on its own doesn't provide enough context.
|
||||
*/
|
||||
#define UI_NUMBER_EVAL_ERROR_PREFIX IFACE_("Error evaluating number, see Info editor for details")
|
||||
|
||||
|
@ -331,7 +331,7 @@ void UI_list_panel_unique_str(Panel *panel, char *r_name)
|
||||
}
|
||||
|
||||
/**
|
||||
* Free a panel and it's children. Custom data is shared by the panel and its children
|
||||
* Free a panel and its children. Custom data is shared by the panel and its children
|
||||
* and is freed by #UI_panels_free_instanced.
|
||||
*
|
||||
* \note The only panels that should need to be deleted at runtime are panels with the
|
||||
|
@ -525,7 +525,7 @@ static uiTooltipData *ui_tooltip_data_from_tool(bContext *C, uiBut *but, bool is
|
||||
*
|
||||
* - Direct access to the tool (as if the toolbar button is pressed).
|
||||
* - The key is bound to a brush type (not the exact brush name).
|
||||
* - The key is assigned to the operator it's self
|
||||
* - The key is assigned to the operator itself
|
||||
* (bypassing the tool, executing the operator).
|
||||
*
|
||||
* Either way case it's useful to show the shortcut.
|
||||
|
@ -131,7 +131,7 @@ struct MenuSearch_Item {
|
||||
} rna;
|
||||
};
|
||||
|
||||
/** Set when we need each menu item to be able to set it's own context. may be NULL. */
|
||||
/** Set when we need each menu item to be able to set its own context. may be NULL. */
|
||||
struct MenuSearch_Context *wm_context;
|
||||
};
|
||||
|
||||
|
@ -2967,7 +2967,7 @@ static void rna_update_cb(bContext *C, void *arg_cb, void *UNUSED(arg))
|
||||
RNAUpdateCb *cb = (RNAUpdateCb *)arg_cb;
|
||||
|
||||
/* we call update here on the pointer property, this way the
|
||||
* owner of the curve mapping can still define it's own update
|
||||
* owner of the curve mapping can still define its own update
|
||||
* and notifier, even if the CurveMapping struct is shared. */
|
||||
RNA_property_update(C, &cb->ptr, cb->prop);
|
||||
}
|
||||
|
@ -390,7 +390,7 @@ static const uint g_shape_preset_hold_action_face[2][3] = {{2, 0, 1}, {3, 5, 4}}
|
||||
*
|
||||
* In order to speed up UI drawing we create some batches that are then
|
||||
* modified by specialized shaders to draw certain elements really fast.
|
||||
* TODO: find a better place. Maybe it's own file?
|
||||
* TODO: find a better place. Maybe its own file?
|
||||
*
|
||||
* \{ */
|
||||
|
||||
|
@ -1264,7 +1264,7 @@ void MASK_OT_slide_spline_curvature(wmOperatorType *ot)
|
||||
{
|
||||
/* identifiers */
|
||||
ot->name = "Slide Spline Curvature";
|
||||
ot->description = "Slide a point on the spline to define it's curvature";
|
||||
ot->description = "Slide a point on the spline to define its curvature";
|
||||
ot->idname = "MASK_OT_slide_spline_curvature";
|
||||
|
||||
/* api callbacks */
|
||||
|
@ -2687,8 +2687,8 @@ bool EDBM_selectmode_disable_multi(struct bContext *C,
|
||||
*
|
||||
* Overview of the algorithm:
|
||||
* - Groups faces surrounded by edges with 3+ faces using them.
|
||||
* - Calculates a cost of each face group comparing it's angle with the faces
|
||||
* connected to it's non-manifold edges.
|
||||
* - Calculates a cost of each face group comparing its angle with the faces
|
||||
* connected to its non-manifold edges.
|
||||
* - Mark the face group as interior, and mark connected face groups for recalculation.
|
||||
* - Continue to remove the face groups with the highest 'cost'.
|
||||
*
|
||||
|
@ -2798,7 +2798,7 @@ static void do_vpaint_brush_calc_average_color_cb_ex(void *__restrict userdata,
|
||||
const MVert *mv = &data->me->mvert[v_index];
|
||||
if (!use_vert_sel || mv->flag & SELECT) {
|
||||
accum->len += gmap->vert_to_loop[v_index].count;
|
||||
/* if a vertex is within the brush region, then add it's color to the blend. */
|
||||
/* if a vertex is within the brush region, then add its color to the blend. */
|
||||
for (int j = 0; j < gmap->vert_to_loop[v_index].count; j++) {
|
||||
const int l_index = gmap->vert_to_loop[v_index].indices[j];
|
||||
col = (char *)(&lcol[l_index]);
|
||||
|
@ -8140,7 +8140,7 @@ static int ed_object_sculptmode_flush_recalc_flag(Scene *scene,
|
||||
int flush_recalc = 0;
|
||||
/* Multires in sculpt mode could have different from object mode subdivision level. */
|
||||
flush_recalc |= mmd && mmd->sculptlvl != mmd->lvl;
|
||||
/* If object has got active modifiers, it's dm could be different in sculpt mode. */
|
||||
/* If object has got active modifiers, its dm could be different in sculpt mode. */
|
||||
flush_recalc |= sculpt_has_active_modifiers(scene, ob);
|
||||
return flush_recalc;
|
||||
}
|
||||
@ -8349,7 +8349,7 @@ static int sculpt_mode_toggle_exec(bContext *C, wmOperator *op)
|
||||
|
||||
if (ob->mode & mode_flag) {
|
||||
Mesh *me = ob->data;
|
||||
/* Dyntopo add's it's own undo step. */
|
||||
/* Dyntopo adds its own undo step. */
|
||||
if ((me->flag & ME_SCULPT_DYNAMIC_TOPOLOGY) == 0) {
|
||||
/* Without this the memfile undo step is used,
|
||||
* while it works it causes lag when undoing the first undo step, see T71564. */
|
||||
|
@ -111,7 +111,7 @@ static int sculpt_detail_flood_fill_exec(bContext *C, wmOperator *UNUSED(op))
|
||||
for (int i = 0; i < totnodes; i++) {
|
||||
BKE_pbvh_node_mark_topology_update(nodes[i]);
|
||||
}
|
||||
/* Get the bounding box, it's center and size. */
|
||||
/* Get the bounding box, its center and size. */
|
||||
BKE_pbvh_bounding_box(ob->sculpt->pbvh, bb_min, bb_max);
|
||||
add_v3_v3v3(center, bb_min, bb_max);
|
||||
mul_v3_fl(center, 0.5f);
|
||||
|
@ -750,7 +750,7 @@ typedef struct SculptBrushTest {
|
||||
/* For circle (not sphere) projection. */
|
||||
float plane_view[4];
|
||||
|
||||
/* Some tool code uses a plane for it's calculateions. */
|
||||
/* Some tool code uses a plane for its calculations. */
|
||||
float plane_tool[4];
|
||||
|
||||
/* View3d clipping - only set rv3d for clipping */
|
||||
|
@ -239,7 +239,7 @@ static bool sculpt_undo_restore_coords(bContext *C, Depsgraph *depsgraph, Sculpt
|
||||
/* Propagate new coords to keyblock. */
|
||||
SCULPT_vertcos_to_key(ob, ss->shapekey_active, vertCos);
|
||||
|
||||
/* PBVH uses it's own mvert array, so coords should be */
|
||||
/* PBVH uses its own mvert array, so coords should be */
|
||||
/* propagated to PBVH here. */
|
||||
BKE_pbvh_vert_coords_apply(ss->pbvh, vertCos, ss->shapekey_active->totelem);
|
||||
|
||||
|
@ -685,7 +685,7 @@ void ED_space_clip_set_clip(bContext *C, bScreen *screen, SpaceClip *sc, MovieCl
|
||||
}
|
||||
}
|
||||
|
||||
/* If clip is no longer visible on screen, free memory used by it's cache */
|
||||
/* If clip is no longer visible on screen, free memory used by its cache */
|
||||
if (old_clip && old_clip != clip && !old_clip_visible) {
|
||||
BKE_movieclip_clear_cache(old_clip);
|
||||
}
|
||||
|
@ -598,7 +598,7 @@ MovieTrackingTrack *tracking_marker_check_slide(
|
||||
*/
|
||||
min_distance_squared = distance_squared;
|
||||
|
||||
/* If search area is visible, check how close to it's sliding
|
||||
/* If search area is visible, check how close to its sliding
|
||||
* zones mouse is.
|
||||
*/
|
||||
if (sc->flag & SC_SHOW_MARKER_SEARCH) {
|
||||
|
@ -165,7 +165,7 @@ static float dist_to_rect(const float co[2],
|
||||
return sqrtf(min_ffff(d1, d2, d3, d4));
|
||||
}
|
||||
|
||||
/* Distance to quad defined by it's corners, corners are relative to pos */
|
||||
/* Distance to quad defined by its corners, corners are relative to pos */
|
||||
static float dist_to_crns(const float co[2], const float pos[2], const float crns[4][2])
|
||||
{
|
||||
float d1, d2, d3, d4;
|
||||
|
@ -740,7 +740,7 @@ static void rna_update_cb(bContext *C, void *arg_cb, void *UNUSED(arg))
|
||||
cb->iuser->ok = 1;
|
||||
|
||||
/* we call update here on the pointer property, this way the
|
||||
* owner of the image pointer can still define it's own update
|
||||
* owner of the image pointer can still define its own update
|
||||
* and notifier */
|
||||
RNA_property_update(C, &cb->ptr, cb->prop);
|
||||
}
|
||||
|
@ -252,7 +252,7 @@ static void stats_object_edit(Object *obedit, SceneStats *stats)
|
||||
stats->totbonesel++;
|
||||
}
|
||||
|
||||
/* if this is a connected child and it's parent is being moved, remove our root */
|
||||
/* if this is a connected child and its parent is being moved, remove our root */
|
||||
if ((ebo->flag & BONE_CONNECTED) && (ebo->flag & BONE_ROOTSEL) && ebo->parent &&
|
||||
(ebo->parent->flag & BONE_TIPSEL)) {
|
||||
stats->totvertsel--;
|
||||
|
@ -303,7 +303,7 @@ static bool textview_draw_string(TextViewDrawState *tds,
|
||||
/**
|
||||
* \param r_mval_pick_item: The resulting item clicked on using \a mval_init.
|
||||
* Set from the void pointer which holds the current iterator.
|
||||
* It's type depends on the data being iterated over.
|
||||
* Its type depends on the data being iterated over.
|
||||
* \param r_mval_pick_offset: The offset in bytes of the \a mval_init.
|
||||
* Use for selection.
|
||||
*/
|
||||
|
@ -449,7 +449,7 @@ static bool ui_node_item_special_poll(const bNodeTree *UNUSED(ntree), const bNod
|
||||
{
|
||||
if (STREQ(ntype->idname, "ShaderNodeUVAlongStroke")) {
|
||||
/* TODO(sergey): Currently we don't have Freestyle nodes edited from
|
||||
* the buttons context, so can ignore it's nodes completely.
|
||||
* the buttons context, so can ignore its nodes completely.
|
||||
*
|
||||
* However, we might want to do some extra checks here later.
|
||||
*/
|
||||
|
@ -62,7 +62,7 @@ void outliner_viewcontext_init(const bContext *C, TreeViewContext *tvc)
|
||||
tvc->ob_edit = OBEDIT_FROM_OBACT(tvc->obact);
|
||||
|
||||
if ((tvc->obact->type == OB_ARMATURE) ||
|
||||
/* This could be made into it's own function. */
|
||||
/* This could be made into its own function. */
|
||||
((tvc->obact->type == OB_MESH) && tvc->obact->mode & OB_MODE_WEIGHT_PAINT)) {
|
||||
tvc->ob_pose = BKE_object_pose_armature_get(tvc->obact);
|
||||
}
|
||||
|
@ -1609,7 +1609,7 @@ static void sequencer_draw_display_buffer(const bContext *C,
|
||||
}
|
||||
|
||||
/* Format needs to be created prior to any #immBindShader call.
|
||||
* Do it here because OCIO binds it's own shader. */
|
||||
* Do it here because OCIO binds its own shader. */
|
||||
eGPUTextureFormat format;
|
||||
eGPUDataFormat data;
|
||||
bool glsl_used = false;
|
||||
|
@ -117,7 +117,7 @@ static SpaceLink *text_duplicate(SpaceLink *sl)
|
||||
|
||||
/* clear or remove stuff from old */
|
||||
|
||||
stextn->runtime.drawcache = NULL; /* space need it's own cache */
|
||||
stextn->runtime.drawcache = NULL; /* space need its own cache */
|
||||
|
||||
return (SpaceLink *)stextn;
|
||||
}
|
||||
|
@ -1531,7 +1531,7 @@ void view3d_draw_region_info(const bContext *C, ARegion *region)
|
||||
else {
|
||||
switch ((eUserpref_MiniAxisType)U.mini_axis_type) {
|
||||
case USER_MINI_AXIS_TYPE_GIZMO:
|
||||
/* The gizmo handles it's own drawing. */
|
||||
/* The gizmo handles its own drawing. */
|
||||
break;
|
||||
case USER_MINI_AXIS_TYPE_MINIMAL:
|
||||
draw_view_axis(rv3d, rect);
|
||||
|
@ -842,7 +842,7 @@ static void viewrotate_apply(ViewOpsData *vod, const int event_xy[2])
|
||||
* This works by blending two horizons:
|
||||
* - Rotated-horizon: `cross_v3_v3v3(xaxis, zvec_global, m_inv[2])`
|
||||
* When only this is used, this turntable rotation works - but it's side-ways
|
||||
* (as if the entire turn-table has been placed on it's side)
|
||||
* (as if the entire turn-table has been placed on its side)
|
||||
* While there is no gimble lock, it's also awkward to use.
|
||||
* - Un-rotated-horizon: `m_inv[0]`
|
||||
* When only this is used, the turntable rotation can have gimbal lock.
|
||||
@ -2763,7 +2763,7 @@ void VIEW3D_OT_dolly(wmOperatorType *ot)
|
||||
/* -------------------------------------------------------------------- */
|
||||
/** \name View All Operator
|
||||
*
|
||||
* Move & Zoom the view to fit all of it's contents.
|
||||
* Move & Zoom the view to fit all of its contents.
|
||||
* \{ */
|
||||
|
||||
static bool view3d_object_skip_minmax(const View3D *v3d,
|
||||
|
@ -1150,7 +1150,7 @@ void VIEW3D_OT_interactive_add(struct wmOperatorType *ot)
|
||||
ot->cancel = view3d_interactive_add_cancel;
|
||||
ot->poll = view3d_interactive_add_poll;
|
||||
|
||||
/* Note, let the operator we call handle undo and registering it's self. */
|
||||
/* Note, let the operator we call handle undo and registering itself. */
|
||||
/* flags */
|
||||
ot->flag = 0;
|
||||
|
||||
|
@ -1112,7 +1112,7 @@ bool ED_view3d_autodist_depth_seg(
|
||||
/* -------------------------------------------------------------------- */
|
||||
/** \name View Radius/Distance Utilities
|
||||
*
|
||||
* Use to calculate a distance to a point based on it's radius.
|
||||
* Use to calculate a distance to a point based on its radius.
|
||||
* \{ */
|
||||
|
||||
float ED_view3d_radius_to_dist_persp(const float angle, const float radius)
|
||||
|
@ -121,7 +121,7 @@ static void gizmo2d_pivot_point_message_subscribe(struct wmGizmoGroup *gzgroup,
|
||||
/* -------------------------------------------------------------------- */
|
||||
/** \name Arrow / Cage Gizmo Group
|
||||
*
|
||||
* Defines public functions, not the gizmo it's self:
|
||||
* Defines public functions, not the gizmo itself:
|
||||
*
|
||||
* - #ED_widgetgroup_gizmo2d_xform_callbacks_set
|
||||
* - #ED_widgetgroup_gizmo2d_xform_no_cage_callbacks_set
|
||||
@ -530,7 +530,7 @@ void ED_widgetgroup_gizmo2d_xform_no_cage_callbacks_set(wmGizmoGroupType *gzgt)
|
||||
/* -------------------------------------------------------------------- */
|
||||
/** \name Scale Handles
|
||||
*
|
||||
* Defines public functions, not the gizmo it's self:
|
||||
* Defines public functions, not the gizmo itself:
|
||||
*
|
||||
* - #ED_widgetgroup_gizmo2d_resize_callbacks_set
|
||||
*
|
||||
@ -686,7 +686,7 @@ void ED_widgetgroup_gizmo2d_resize_callbacks_set(wmGizmoGroupType *gzgt)
|
||||
/* -------------------------------------------------------------------- */
|
||||
/** \name Rotate Handles
|
||||
*
|
||||
* Defines public functions, not the gizmo it's self:
|
||||
* Defines public functions, not the gizmo itself:
|
||||
*
|
||||
* - #ED_widgetgroup_gizmo2d_rotate_setup
|
||||
*
|
||||
|
@ -364,7 +364,7 @@ bool ED_undo_is_legacy_compatible_for_property(struct bContext *C, ID *id)
|
||||
if (obact != NULL) {
|
||||
if (obact->mode & OB_MODE_ALL_PAINT) {
|
||||
/* Don't store property changes when painting
|
||||
* (only do undo pushes on brush strokes which each paint operator handles on it's own). */
|
||||
* (only do undo pushes on brush strokes which each paint operator handles on its own). */
|
||||
CLOG_INFO(&LOG, 1, "skipping undo for paint-mode");
|
||||
return false;
|
||||
}
|
||||
|
@ -66,7 +66,7 @@ void param_delete(ParamHandle *handle);
|
||||
* -----------------------------
|
||||
* - charts with less than two pinned vertices are assigned 2 pins
|
||||
* - lscm is divided in three steps:
|
||||
* - begin: compute matrix and it's factorization (expensive)
|
||||
* - begin: compute matrix and its factorization (expensive)
|
||||
* - solve using pinned coordinates (cheap)
|
||||
* - end: clean up
|
||||
* - uv coordinates are allowed to change within begin/end, for
|
||||
|
@ -73,7 +73,7 @@ typedef struct ULData {
|
||||
* around the connected fan are attached to an edge.
|
||||
*
|
||||
* In this case there is no need to detect contiguous loops,
|
||||
* each isolated case is handled on it's own, no need to walk over selected edges.
|
||||
* each isolated case is handled on its own, no need to walk over selected edges.
|
||||
*
|
||||
* \note This flag isn't flushed to other loops which could also have this enabled.
|
||||
* Currently it's not necessary since we can start off on any one of these loops,
|
||||
|
@ -20,7 +20,7 @@
|
||||
* \ingroup fn
|
||||
*
|
||||
* An ArraySpan is a span where every element contains an array (instead of a single element as is
|
||||
* the case in a normal span). It's main use case is to reference many small arrays.
|
||||
* the case in a normal span). Its main use case is to reference many small arrays.
|
||||
*/
|
||||
|
||||
#include "FN_spans.hh"
|
||||
|
@ -55,7 +55,7 @@ typedef enum eGPUBatchFlag {
|
||||
|
||||
/** Has been initialized. At least one VBO is set. */
|
||||
GPU_BATCH_INIT = (1 << 16),
|
||||
/** Batch is initialized but it's VBOs are still being populated. (optional) */
|
||||
/** Batch is initialized but its VBOs are still being populated. (optional) */
|
||||
GPU_BATCH_BUILDING = (1 << 16),
|
||||
/** Cached data need to be rebuild. (VAO, PSO, ...) */
|
||||
GPU_BATCH_DIRTY = (1 << 17),
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user