Cleanup: spelling in code

intern/cycles/kernel/svm/wavelength.h

@@ -27,7 +27,7 @@ ccl_device_noinline void svm_node_wavelength(KernelGlobals kg,
   }
   else {
     ii -= i;
-    ccl_constant float *c = cie_colour_match[i];
+    ccl_constant float *c = cie_color_match[i];
     color = interp(make_float3(c[0], c[1], c[2]), make_float3(c[3], c[4], c[5]), ii);
   }
 

intern/cycles/kernel/tables.h

@@ -34,7 +34,7 @@ ccl_inline_constant float blackbody_table_b[][4] = {
  {6.72650283e-13f, -2.73078809e-08f, 4.24098264e-04f, -7.52335691e-01f}
 };
 
-ccl_inline_constant float cie_colour_match[][3] = {
+ccl_inline_constant float cie_color_match[][3] = {
   {0.0014f, 0.0000f, 0.0065f}, {0.0022f, 0.0001f, 0.0105f}, {0.0042f, 0.0001f, 0.0201f},
   {0.0076f, 0.0002f, 0.0362f}, {0.0143f, 0.0004f, 0.0679f}, {0.0232f, 0.0006f, 0.1102f},
   {0.0435f, 0.0012f, 0.2074f}, {0.0776f, 0.0022f, 0.3713f}, {0.1344f, 0.0040f, 0.6456f},

source/blender/blenkernel/intern/node_tree_anonymous_attributes.cc

@@ -232,7 +232,7 @@ static bool or_into_each_other(BitGroupVector<> &vec, const int64_t a, const int
   return or_into_each_other(vec[a], vec[b]);
 }
 
-static AnonymousAttributeInferencingResult analyse_anonymous_attribute_usages(
+static AnonymousAttributeInferencingResult analyze_anonymous_attribute_usages(
     const bNodeTree &tree)
 {
   BLI_assert(!tree.has_available_link_cycle());
@@ -643,7 +643,7 @@ bool update_anonymous_attribute_relations(bNodeTree &tree)
     return changed;
   }
 
-  AnonymousAttributeInferencingResult result = analyse_anonymous_attribute_usages(tree);
+  AnonymousAttributeInferencingResult result = analyze_anonymous_attribute_usages(tree);
 
   const bool group_interface_changed =
       !tree.runtime->anonymous_attribute_inferencing ||

source/blender/compositor/realtime_compositor/shaders/compositor_displace.glsl

@@ -42,14 +42,14 @@ void main()
    * standard backward finite difference equation, because multiplication by -1 flips the order of
    * subtraction. */
   int x_step = (table_index.x % 2) * -2 + 1;
-  vec2 x_neighbour = displaced_coordinates_table[table_index.x + x_step][table_index.y];
+  vec2 x_neighbor = displaced_coordinates_table[table_index.x + x_step][table_index.y];
-  vec2 x_gradient = (x_neighbour - displaced_coordinates) * x_step;
+  vec2 x_gradient = (x_neighbor - displaced_coordinates) * x_step;
 
   /* Compute the partial derivative of the displaced coordinates along the y direction using a
    * finite difference approximation. See the previous code section for more information. */
   int y_step = (table_index.y % 2) * -2 + 1;
-  vec2 y_neighbour = displaced_coordinates_table[table_index.x][table_index.y + y_step];
+  vec2 y_neighbor = displaced_coordinates_table[table_index.x][table_index.y + y_step];
-  vec2 y_gradient = (y_neighbour - displaced_coordinates) * y_step;
+  vec2 y_gradient = (y_neighbor - displaced_coordinates) * y_step;
 
   /* Sample the input using the displaced coordinates passing in the computed gradients in order to
    * utilize the anisotropic filtering capabilities of the sampler. */

source/blender/compositor/realtime_compositor/shaders/compositor_double_edge_mask_compute_boundary.glsl

@@ -18,9 +18,9 @@ void main()
 {
   ivec2 texel = ivec2(gl_GlobalInvocationID.xy);
 
-  /* Identify if any of the 8 neighbours around the center pixel are not masked. */
+  /* Identify if any of the 8 neighbors around the center pixel are not masked. */
-  bool has_inner_non_masked_neighbours = false;
+  bool has_inner_non_masked_neighbors = false;
-  bool has_outer_non_masked_neighbours = false;
+  bool has_outer_non_masked_neighbors = false;
   for (int j = -1; j <= 1; j++) {
     for (int i = -1; i <= 1; i++) {
       ivec2 offset = ivec2(i, j);
@@ -31,7 +31,7 @@ void main()
       }
 
       if (texture_load(inner_mask_tx, texel + offset).x == 0.0) {
-        has_inner_non_masked_neighbours = true;
+        has_inner_non_masked_neighbors = true;
       }
 
       /* If the user specified include_edges_of_image to be true, then we assume the outer mask is
@@ -39,11 +39,11 @@ void main()
        * practically implemented by falling back to 0.0 or 1.0 for out of bound pixels. */
       vec4 boundary_fallback = include_edges_of_image ? vec4(0.0) : vec4(1.0);
       if (texture_load(outer_mask_tx, texel + offset, boundary_fallback).x == 0.0) {
-        has_outer_non_masked_neighbours = true;
+        has_outer_non_masked_neighbors = true;
       }
 
       /* Both are true, no need to continue. */
-      if (has_inner_non_masked_neighbours && has_outer_non_masked_neighbours) {
+      if (has_inner_non_masked_neighbors && has_outer_non_masked_neighbors) {
         break;
       }
     }
@@ -52,12 +52,12 @@ void main()
   bool is_inner_masked = texture_load(inner_mask_tx, texel).x > 0.0;
   bool is_outer_masked = texture_load(outer_mask_tx, texel).x > 0.0;
 
-  /* The pixels at the boundary are those that are masked and have non masked neighbours. The inner
+  /* The pixels at the boundary are those that are masked and have non masked neighbors. The inner
    * boundary has a specialization, if include_all_inner_edges is false, only inner boundaries that
    * lie inside the outer mask will be considered a boundary. */
-  bool is_inner_boundary = is_inner_masked && has_inner_non_masked_neighbours &&
+  bool is_inner_boundary = is_inner_masked && has_inner_non_masked_neighbors &&
                            (is_outer_masked || include_all_inner_edges);
-  bool is_outer_boundary = is_outer_masked && has_outer_non_masked_neighbours;
+  bool is_outer_boundary = is_outer_masked && has_outer_non_masked_neighbors;
 
   /* Encode the boundary information in the format expected by the jump flooding algorithm. */
   ivec2 inner_jump_flooding_value = initialize_jump_flooding_value(texel, is_inner_boundary);

source/blender/compositor/realtime_compositor/shaders/compositor_glare_simple_star_anti_diagonal_pass.glsl

@@ -27,8 +27,8 @@ void main()
       vec4 current_input = imageLoad(anti_diagonal_img, texel);
       vec4 next_input = imageLoad(anti_diagonal_img, texel + i * direction);
 
-      vec4 neighbour_average = (previous_output + next_input) / 2.0;
+      vec4 neighbor_average = (previous_output + next_input) / 2.0;
-      vec4 causal_output = mix(current_input, neighbour_average, fade_factor);
+      vec4 causal_output = mix(current_input, neighbor_average, fade_factor);
       imageStore(anti_diagonal_img, texel, causal_output);
     }
 
@@ -42,8 +42,8 @@ void main()
       vec4 current_input = imageLoad(anti_diagonal_img, texel);
       vec4 next_input = imageLoad(anti_diagonal_img, texel - i * direction);
 
-      vec4 neighbour_average = (previous_output + next_input) / 2.0;
+      vec4 neighbor_average = (previous_output + next_input) / 2.0;
-      vec4 non_causal_output = mix(current_input, neighbour_average, fade_factor);
+      vec4 non_causal_output = mix(current_input, neighbor_average, fade_factor);
       imageStore(anti_diagonal_img, texel, non_causal_output);
     }
   }

source/blender/compositor/realtime_compositor/shaders/compositor_glare_simple_star_diagonal_pass.glsl

@@ -26,8 +26,8 @@ void main()
       vec4 current_input = imageLoad(diagonal_img, texel);
       vec4 next_input = imageLoad(diagonal_img, texel + i * direction);
 
-      vec4 neighbour_average = (previous_output + next_input) / 2.0;
+      vec4 neighbor_average = (previous_output + next_input) / 2.0;
-      vec4 causal_output = mix(current_input, neighbour_average, fade_factor);
+      vec4 causal_output = mix(current_input, neighbor_average, fade_factor);
       imageStore(diagonal_img, texel, causal_output);
     }
 
@@ -41,8 +41,8 @@ void main()
       vec4 current_input = imageLoad(diagonal_img, texel);
       vec4 next_input = imageLoad(diagonal_img, texel - i * direction);
 
-      vec4 neighbour_average = (previous_output + next_input) / 2.0;
+      vec4 neighbor_average = (previous_output + next_input) / 2.0;
-      vec4 non_causal_output = mix(current_input, neighbour_average, fade_factor);
+      vec4 non_causal_output = mix(current_input, neighbor_average, fade_factor);
       imageStore(diagonal_img, texel, non_causal_output);
     }
   }

source/blender/compositor/realtime_compositor/shaders/compositor_glare_simple_star_horizontal_pass.glsl

@@ -19,8 +19,8 @@ void main()
       vec4 current_input = imageLoad(horizontal_img, texel);
       vec4 next_input = imageLoad(horizontal_img, texel + ivec2(i, 0));
 
-      vec4 neighbour_average = (previous_output + next_input) / 2.0;
+      vec4 neighbor_average = (previous_output + next_input) / 2.0;
-      vec4 causal_output = mix(current_input, neighbour_average, fade_factor);
+      vec4 causal_output = mix(current_input, neighbor_average, fade_factor);
       imageStore(horizontal_img, texel, causal_output);
     }
 
@@ -34,8 +34,8 @@ void main()
       vec4 current_input = imageLoad(horizontal_img, texel);
       vec4 next_input = imageLoad(horizontal_img, texel - ivec2(i, 0));
 
-      vec4 neighbour_average = (previous_output + next_input) / 2.0;
+      vec4 neighbor_average = (previous_output + next_input) / 2.0;
-      vec4 non_causal_output = mix(current_input, neighbour_average, fade_factor);
+      vec4 non_causal_output = mix(current_input, neighbor_average, fade_factor);
       imageStore(horizontal_img, texel, non_causal_output);
     }
   }

source/blender/compositor/realtime_compositor/shaders/compositor_glare_simple_star_vertical_pass.glsl

@@ -21,8 +21,8 @@ void main()
       vec4 current_input = imageLoad(vertical_img, texel);
       vec4 next_input = imageLoad(vertical_img, texel + ivec2(0, i));
 
-      vec4 neighbour_average = (previous_output + next_input) / 2.0;
+      vec4 neighbor_average = (previous_output + next_input) / 2.0;
-      vec4 causal_output = mix(current_input, neighbour_average, fade_factor);
+      vec4 causal_output = mix(current_input, neighbor_average, fade_factor);
       imageStore(vertical_img, texel, causal_output);
     }
 
@@ -36,8 +36,8 @@ void main()
       vec4 current_input = imageLoad(vertical_img, texel);
       vec4 next_input = imageLoad(vertical_img, texel - ivec2(0, i));
 
-      vec4 neighbour_average = (previous_output + next_input) / 2.0;
+      vec4 neighbor_average = (previous_output + next_input) / 2.0;
-      vec4 non_causal_output = mix(current_input, neighbour_average, fade_factor);
+      vec4 non_causal_output = mix(current_input, neighbor_average, fade_factor);
       imageStore(vertical_img, texel, non_causal_output);
     }
   }

source/blender/compositor/realtime_compositor/shaders/compositor_glare_streaks_filter.glsl

@@ -17,29 +17,29 @@ void main()
 
   /* Load three equally spaced neighbors to the current pixel in the direction of the streak
    * vector. */
-  vec4 neighbours[3];
+  vec4 neighbors[3];
-  neighbours[0] = texture(input_streak_tx, coordinates + vector);
+  neighbors[0] = texture(input_streak_tx, coordinates + vector);
-  neighbours[1] = texture(input_streak_tx, coordinates + vector * 2.0);
+  neighbors[1] = texture(input_streak_tx, coordinates + vector * 2.0);
-  neighbours[2] = texture(input_streak_tx, coordinates + vector * 3.0);
+  neighbors[2] = texture(input_streak_tx, coordinates + vector * 3.0);
 
   /* Attenuate the value of two of the channels for each of the neighbors by multiplying by the
    * color modulator. The particular channels for each neighbor were chosen to be visually similar
    * to the modulation pattern of chromatic aberration. */
-  neighbours[0].gb *= color_modulator;
+  neighbors[0].gb *= color_modulator;
-  neighbours[1].rg *= color_modulator;
+  neighbors[1].rg *= color_modulator;
-  neighbours[2].rb *= color_modulator;
+  neighbors[2].rb *= color_modulator;
 
   /* Compute the weighted sum of all neighbors using the given fade factors as weights. The
    * weights are expected to be lower for neighbors that are further away. */
-  vec4 weighted_neighbours_sum = vec4(0.0);
+  vec4 weighted_neighbors_sum = vec4(0.0);
   for (int i = 0; i < 3; i++) {
-    weighted_neighbours_sum += fade_factors[i] * neighbours[i];
+    weighted_neighbors_sum += fade_factors[i] * neighbors[i];
   }
 
   /* The output is the average between the center color and the weighted sum of the neighbors.
    * Which intuitively mean that highlights will spread in the direction of the streak, which is
    * the desired result. */
   vec4 center_color = texture(input_streak_tx, coordinates);
-  vec4 output_color = (center_color + weighted_neighbours_sum) / 2.0;
+  vec4 output_color = (center_color + weighted_neighbors_sum) / 2.0;
   imageStore(output_streak_img, texel, output_color);
 }

source/blender/compositor/realtime_compositor/shaders/compositor_inpaint_compute_boundary.glsl

@@ -18,8 +18,8 @@ void main()
 {
   ivec2 texel = ivec2(gl_GlobalInvocationID.xy);
 
-  /* Identify if any of the 8 neighbours around the center pixel are transparent. */
+  /* Identify if any of the 8 neighbors around the center pixel are transparent. */
-  bool has_transparent_neighbours = false;
+  bool has_transparent_neighbors = false;
   for (int j = -1; j <= 1; j++) {
     for (int i = -1; i <= 1; i++) {
       ivec2 offset = ivec2(i, j);
@@ -27,16 +27,16 @@ void main()
       /* Exempt the center pixel. */
       if (all(notEqual(offset, ivec2(0)))) {
         if (texture_load(input_tx, texel + offset).a < 1.0) {
-          has_transparent_neighbours = true;
+          has_transparent_neighbors = true;
           break;
         }
       }
     }
   }
 
-  /* The pixels at the boundary are those that are opaque and have transparent neighbours. */
+  /* The pixels at the boundary are those that are opaque and have transparent neighbors. */
   bool is_opaque = texture_load(input_tx, texel).a == 1.0;
-  bool is_boundary_pixel = is_opaque && has_transparent_neighbours;
+  bool is_boundary_pixel = is_opaque && has_transparent_neighbors;
 
   /* Encode the boundary information in the format expected by the jump flooding algorithm. */
   ivec2 jump_flooding_value = initialize_jump_flooding_value(texel, is_boundary_pixel);

source/blender/compositor/realtime_compositor/shaders/compositor_keying_tweak_matte.glsl

@@ -20,8 +20,8 @@ void main()
     int count = 0;
     for (int j = -edge_search_radius; j <= edge_search_radius; j++) {
       for (int i = -edge_search_radius; i <= edge_search_radius; i++) {
-        float neighbour_matte = texture_load(input_matte_tx, texel + ivec2(i, j)).x;
+        float neighbor_matte = texture_load(input_matte_tx, texel + ivec2(i, j)).x;
-        count += int(distance(matte, neighbour_matte) < edge_tolerance);
+        count += int(distance(matte, neighbor_matte) < edge_tolerance);
       }
     }
 

source/blender/compositor/realtime_compositor/shaders/compositor_map_uv.glsl

@@ -32,14 +32,14 @@ void main()
    * standard backward finite difference equation, because multiplication by -1 flips the order of
    * subtraction. */
   int x_step = (table_index.x % 2) * -2 + 1;
-  vec2 x_neighbour = uv_coordinates_table[table_index.x + x_step][table_index.y];
+  vec2 x_neighbor = uv_coordinates_table[table_index.x + x_step][table_index.y];
-  vec2 x_gradient = (x_neighbour - uv_coordinates) * x_step;
+  vec2 x_gradient = (x_neighbor - uv_coordinates) * x_step;
 
   /* Compute the partial derivative of the UV coordinates along the y direction using a
    * finite difference approximation. See the previous code section for more information. */
   int y_step = (table_index.y % 2) * -2 + 1;
-  vec2 y_neighbour = uv_coordinates_table[table_index.x][table_index.y + y_step];
+  vec2 y_neighbor = uv_coordinates_table[table_index.x][table_index.y + y_step];
-  vec2 y_gradient = (y_neighbour - uv_coordinates) * y_step;
+  vec2 y_gradient = (y_neighbor - uv_coordinates) * y_step;
 
   /* Sample the input using the UV coordinates passing in the computed gradients in order to
    * utilize the anisotropic filtering capabilities of the sampler. */

source/blender/draw/engines/overlay/shaders/overlay_motion_path_line_vert_no_geom.glsl

@@ -28,10 +28,10 @@ vec2 compute_dir(vec2 v0, vec2 v1)
   return dir;
 }
 
-void do_vertex_shader(vec4 pos, int vertex_id, out vec2 out_sspos, out vec4 out_finalcolour)
+void do_vertex_shader(vec4 pos, int vertex_id, out vec2 out_sspos, out vec4 out_finalcolor)
 {
   out_sspos = proj(pos);
-  out_finalcolour = vec4(0.0);
+  out_finalcolor = vec4(0.0);
 
   int frame = vertex_id + cacheStart;
   float intensity; /* how faint */
@@ -43,7 +43,7 @@ void do_vertex_shader(vec4 pos, int vertex_id, out vec2 out_sspos, out vec4 out_
   if (frame < frameCurrent) {
     if (use_custom_color) {
       /* Custom color: previous frames color is darker than current frame */
-      out_finalcolour.rgb = customColor * 0.25;
+      out_finalcolor.rgb = customColor * 0.25;
     }
     else {
       /* black - before frameCurrent */
@@ -53,13 +53,13 @@ void do_vertex_shader(vec4 pos, int vertex_id, out vec2 out_sspos, out vec4 out_
       else {
         intensity = SET_INTENSITY(frameStart, frame, frameCurrent, 0.68, 0.92);
       }
-      out_finalcolour.rgb = mix(colorWire.rgb, blend_base, intensity);
+      out_finalcolor.rgb = mix(colorWire.rgb, blend_base, intensity);
     }
   }
   else if (frame > frameCurrent) {
     if (use_custom_color) {
       /* Custom color: next frames color is equal to user selected color */
-      out_finalcolour.rgb = customColor;
+      out_finalcolor.rgb = customColor;
     }
     else {
       /* blue - after frameCurrent */
@@ -70,13 +70,13 @@ void do_vertex_shader(vec4 pos, int vertex_id, out vec2 out_sspos, out vec4 out_
         intensity = SET_INTENSITY(frameCurrent, frame, frameEnd, 0.68, 0.92);
       }
 
-      out_finalcolour.rgb = mix(colorBonePose.rgb, blend_base, intensity);
+      out_finalcolor.rgb = mix(colorBonePose.rgb, blend_base, intensity);
     }
   }
   else {
     if (use_custom_color) {
       /* Custom color: current frame color is slightly darker than user selected color */
-      out_finalcolour.rgb = customColor * 0.5;
+      out_finalcolor.rgb = customColor * 0.5;
     }
     else {
       /* green - on frameCurrent */
@@ -86,10 +86,10 @@ void do_vertex_shader(vec4 pos, int vertex_id, out vec2 out_sspos, out vec4 out_
       else {
         intensity = 0.75f;
       }
-      out_finalcolour.rgb = mix(colorBackground.rgb, blend_base, intensity);
+      out_finalcolor.rgb = mix(colorBackground.rgb, blend_base, intensity);
     }
   }
-  out_finalcolour.a = 1.0;
+  out_finalcolor.a = 1.0;
 }
 
 void main()

source/blender/gpu/shaders/common/gpu_shader_smaa_lib.glsl

@@ -615,7 +615,7 @@ float mad(float a, float b, float c)
 /**
  * Gathers current pixel, and the top-left neighbors.
  */
-float3 SMAAGatherNeighbours(float2 texcoord, float4 offset[3], SMAATexture2D(tex))
+float3 SMAAGatherNeighbors(float2 texcoord, float4 offset[3], SMAATexture2D(tex))
 {
 #ifdef SMAAGather
   return SMAAGather(tex, texcoord + SMAA_RT_METRICS.xy * float2(-0.5, -0.5)).grb;
@@ -634,8 +634,8 @@ float2 SMAACalculatePredicatedThreshold(float2 texcoord,
                                         float4 offset[3],
                                         SMAATexture2D(predicationTex))
 {
-  float3 neighbours = SMAAGatherNeighbours(texcoord, offset, SMAATexturePass2D(predicationTex));
+  float3 neighbors = SMAAGatherNeighbors(texcoord, offset, SMAATexturePass2D(predicationTex));
-  float2 delta = abs(neighbours.xx - neighbours.yz);
+  float2 delta = abs(neighbors.xx - neighbors.yz);
   float2 edges = step(SMAA_PREDICATION_THRESHOLD, delta);
   return SMAA_PREDICATION_SCALE * SMAA_THRESHOLD * (1.0 - SMAA_PREDICATION_STRENGTH * edges);
 }
@@ -876,8 +876,8 @@ float2 SMAAColorEdgeDetectionPS(float2 texcoord,
  */
 float2 SMAADepthEdgeDetectionPS(float2 texcoord, float4 offset[3], SMAATexture2D(depthTex))
 {
-  float3 neighbours = SMAAGatherNeighbours(texcoord, offset, SMAATexturePass2D(depthTex));
+  float3 neighbors = SMAAGatherNeighbors(texcoord, offset, SMAATexturePass2D(depthTex));
-  float2 delta = abs(neighbours.xx - float2(neighbours.y, neighbours.z));
+  float2 delta = abs(neighbors.xx - float2(neighbors.y, neighbors.z));
   float2 edges = step(SMAA_DEPTH_THRESHOLD, delta);
 
 #  ifdef GPU_FRAGMENT_SHADER

source/blender/imbuf/intern/colormanagement.cc

@@ -4365,7 +4365,7 @@ void IMB_colormanagement_blackbody_temperature_to_rgb_table(float *r_table,
  * \endcode
  */
 
-static float cie_colour_match[81][3] = {
+static float cie_color_match[81][3] = {
     {0.0014f, 0.0000f, 0.0065f}, {0.0022f, 0.0001f, 0.0105f}, {0.0042f, 0.0001f, 0.0201f},
     {0.0076f, 0.0002f, 0.0362f}, {0.0143f, 0.0004f, 0.0679f}, {0.0232f, 0.0006f, 0.1102f},
     {0.0435f, 0.0012f, 0.2074f}, {0.0776f, 0.0022f, 0.3713f}, {0.1344f, 0.0040f, 0.6456f},
@@ -4406,7 +4406,7 @@ static void wavelength_to_xyz(float xyz[3], float lambda_nm)
   }
   else {
     ii -= float(i);
-    const float *c = cie_colour_match[i];
+    const float *c = cie_color_match[i];
     xyz[0] = c[0] + ii * (c[3] - c[0]);
     xyz[1] = c[1] + ii * (c[4] - c[1]);
     xyz[2] = c[2] + ii * (c[5] - c[2]);

source/blender/nodes/composite/nodes/node_composite_trackpos.cc

@@ -169,13 +169,13 @@ class TrackPositionOperation : public NodeOperation {
     /* Compute the speed as the difference between the previous marker position and the current
      * marker position. Notice that we compute the speed from the current to the previous position,
      * not the other way around. */
-    const float2 previous_marker_position = compute_temporally_neighbouring_marker_position(
+    const float2 previous_marker_position = compute_temporally_neighboring_marker_position(
         track, current_marker_position, -1);
     const float2 speed_toward_previous = previous_marker_position - current_marker_position;
 
     /* Compute the speed as the difference between the current marker position and the next marker
      * position. */
-    const float2 next_marker_position = compute_temporally_neighbouring_marker_position(
+    const float2 next_marker_position = compute_temporally_neighboring_marker_position(
         track, current_marker_position, 1);
     const float2 speed_toward_next = current_marker_position - next_marker_position;
 
@@ -210,7 +210,7 @@ class TrackPositionOperation : public NodeOperation {
    * marker exist for that particular frame or is disabled, the current marker position is
    * returned. This is useful for computing the speed by providing small negative and positive
    * delta times. */
-  float2 compute_temporally_neighbouring_marker_position(MovieTrackingTrack *track,
+  float2 compute_temporally_neighboring_marker_position(MovieTrackingTrack *track,
                                                         float2 current_marker_position,
                                                         int time_delta)
   {

source/blender/nodes/geometry/nodes/node_geo_input_shortest_edge_paths.cc

@@ -59,11 +59,11 @@ static void shortest_paths(const Mesh &mesh,
         continue;
       }
       const float edge_cost = std::max(0.0f, input_cost[edge_i]);
-      const float new_neighbour_cost = cost_i + edge_cost;
+      const float new_neighbor_cost = cost_i + edge_cost;
-      if (new_neighbour_cost < r_cost[neighbor_vert_i]) {
+      if (new_neighbor_cost < r_cost[neighbor_vert_i]) {
-        r_cost[neighbor_vert_i] = new_neighbour_cost;
+        r_cost[neighbor_vert_i] = new_neighbor_cost;
         r_next_index[neighbor_vert_i] = vert_i;
-        queue.emplace(new_neighbour_cost, neighbor_vert_i);
+        queue.emplace(new_neighbor_cost, neighbor_vert_i);
       }
     }
   }

source/blender/render/intern/texture_margin.cc

@@ -251,7 +251,7 @@ class TextureMarginMap {
 
           int other_poly;
           bool found_pixel_in_polygon = false;
-          if (lookup_pixel_polygon_neighbourhood(x, y, &face, &destX, &destY, &other_poly)) {
+          if (lookup_pixel_polygon_neighborhood(x, y, &face, &destX, &destY, &other_poly)) {
 
             for (int i = 0; i < maxPolygonSteps; i++) {
               /* Force to pixel grid. */
@@ -326,7 +326,7 @@ class TextureMarginMap {
    * face we need can be the one next to the one the Dijkstra map provides. To prevent missing
    * pixels also check the neighboring polygons.
    */
-  bool lookup_pixel_polygon_neighbourhood(
+  bool lookup_pixel_polygon_neighborhood(
       float x, float y, uint32_t *r_start_poly, float *r_destx, float *r_desty, int *r_other_poly)
   {
     float found_dist;