Blender Weighted Normal

Visual Comparison

开启前 / Before apply

开启后 / After apply

Before enabling Weighted Normal, the rendering result is not smooth.

The benefits in the images come entirely from the weighted calculation of the normals, without increasing the number of vertices and triangles. If the same effect were to be achieved through subdivision, the number of triangles could increase by up to 16 times.

Principle

The principle is actually very simple. Suppose a vertex $p$ is shared by 4 faces. Since the vertex itself has no concept of normals, the normal at the vertex can only be determined by the normals of the faces it belongs to. When different faces are selected to calculate the normal, 4 different normals $n_1, n_2, n_3, n_4$ will be obtained.

If the normal of each face is calculated separately and the calculation result is directly sent from the vertex shader to the fragment shader for interpolation, the normals of the four faces will be completely discontinuous, resulting in a sharp edge. This rendering technique is called Flat Shading.

The common solution is to store normals at the vertices and use the GPU's interpolation capabilities to calculate the normals at various points on the surface, thus eliminating sharp edges. This rendering technique is called Smooth Shading.

平滑渲染 / Smooth Shading

加权法线 / Weighted Normal

This method works well for models with a high polygon count, but for models with a lower polygon count or complex surface shapes, the results are not as ideal.

Source Code Analysis

Blender Weighted Normal Node - Github

Weighted Normal ensures the smooth transition of normals at the corners of faces by taking the weighted average of these 4 normals, resulting in a smoother rendering effect in the shading stage.

The core algorithm for the FaceArea mode of the Weighted Normal modifier can be broken down into the following steps:

// 1. Initialization
prepare_data()
initialize_buffers()

// 2. Face area calculation
for each face of mesh:
  with different mode,
  face area:
    calculate_weight_by_face_area()
  corner angle:
    calculate_weight_by_corner_angle()
  face area and corner angle:
    calculate_weight_by_face_area_and_corner_angle()

sort_face_by_its_weight()

// 3. Normal aggregation
for each face of sorted faces:
    for each vertex of face:
      // 3.1. aggregate normal to the vertex's weighted normal
      let weight = exponentially_decreasing_weight(vertex.id)
      vertex.normal += vertex.normal * weight

// 4. Normalization
normalize_vertex_normals()

// 5. Cleanup
free_allocated_buffers()