在软渲染器中实现法线贴图 (Normal Mapping)

// include/core/shader.h
struct VertexInput {
    vec3f position;
    vec3f normal;
    vec2f uv;
    vec3f tangent;   // Added
    vec3f bitangent; // Added
};

// include/core/shader.h
struct Varyings {
    vec4f clipPosition;
    vec3f worldPosition;
    vec2f uv;
    // World-space TBN basis vectors
    vec3f tangent;   // World Tangent
    vec3f bitangent; // World Bitangent
    vec3f normal;    // World (Geometric) Normal
};

// src/core/blinn_phong_shader.cpp
Varyings BlinnPhongShader::vertex(const VertexInput& input) {
    Varyings output;
    vec4f modelPos4(input.position, 1.0f);
    vec4f modelNormal4(input.normal, 0.0f);
    vec4f modelTangent4(input.tangent, 0.0f);
    vec4f modelBitangent4(input.bitangent, 0.0f);

    // Calculate world position
    output.worldPosition = (uniform_ModelMatrix * modelPos4).xyz();

    // Transform TBN vectors to world space using Normal Matrix
    // uniform_NormalMatrix is typically transpose(inverse(ModelMatrix))
    // Ensure they are normalized after transformation.
    output.normal    = (uniform_NormalMatrix * modelNormal4).xyz().normalized();
    output.tangent   = (uniform_NormalMatrix * modelTangent4).xyz().normalized();
    output.bitangent = (uniform_NormalMatrix * modelBitangent4).xyz().normalized();
    // Optional: Recalculate bitangent worldB = cross(worldN, worldT) here for robustness.

    // Pass UVs
    output.uv = input.uv;

    // Calculate clip space position
    output.clipPosition = uniform_MVP * modelPos4;

    return output;
}

// src/core/blinn_phong_shader.cpp
bool BlinnPhongShader::fragment(const Varyings& input, vec3f& outColor) {
    vec3f N; // The final normal used for lighting

    if (uniform_UseNormalMap && !uniform_NormalTexture.empty()) {
        // 1. Sample the normal map
        vec3f tangentNormalSample = uniform_NormalTexture.sample(input.uv.x, input.uv.y);

        // 2. Unpack from [0,1] to [-1,1] and normalize
        vec3f tangentNormal = (tangentNormalSample * 2.0f) - vec3f(1.0f, 1.0f, 1.0f);
        tangentNormal = tangentNormal.normalized(); // Ensure unit length

        // 3. Get interpolated world-space TBN basis (renormalize)
        vec3f T = input.tangent.normalized();
        vec3f B = input.bitangent.normalized();
        vec3f N_geom = input.normal.normalized();

        // 4. Transform tangent-space normal to world space
        // N_world = T*Nx_tan + B*Ny_tan + N_geom*Nz_tan
        N = T * tangentNormal.x + B * tangentNormal.y + N_geom * tangentNormal.z;
        N = N.normalized(); // Final normal for lighting
    } else {
        // Use interpolated geometric normal if no normal map
        N = input.normal.normalized();
    }

    // --- Proceed with Blinn-Phong lighting using the final Normal N ---
    vec3f V = (uniform_CameraPosition - input.worldPosition).normalized(); // View direction
    vec3f totalColor = uniform_AmbientLight * uniform_AmbientColor; // Start with ambient

    // Get material properties (potentially textured)
    vec3f matDiffuse = uniform_DiffuseColor;
    if (!uniform_DiffuseTexture.empty()) {
        matDiffuse = matDiffuse * uniform_DiffuseTexture.sample(input.uv.x, input.uv.y);
    }
    // ... (Get matSpecular, matShininess) ...

    for (const auto& light : uniform_Lights) {
        // ... (Calculate L, lightCol, attenuation) ...

        // Diffuse
        float NdotL = std::max(0.0f, N.dot(L));
        vec3f diffuse = matDiffuse * lightCol * NdotL * attenuation;

        // Specular (Blinn-Phong)
        vec3f H = (L + V).normalized();
        float NdotH = std::max(0.0f, N.dot(H));
        float specFactor = fastPow(NdotH, uniform_Shininess); // Use the fastPow utility
        vec3f specular = uniform_SpecularColor * lightCol * specFactor * attenuation;

        totalColor = totalColor + diffuse + specular;
    }

    // Clamp final color
    outColor.x = std::min(1.0f, std::max(0.0f, totalColor.x));
    outColor.y = std::min(1.0f, std::max(0.0f, totalColor.y));
    outColor.z = std::min(1.0f, std::max(0.0f, totalColor.z));

    return true; // Pixel should be written
}

// src/core/renderer.cpp
Varyings Renderer::interpolateVaryings(float t, const Varyings& start, const Varyings& end, float startInvW, float endInvW) const {
    Varyings result;
    // ... (Interpolate worldPosition, uv) ...
    result.normal = perspectiveCorrectInterpolate(t, start.normal, end.normal, startInvW, endInvW);
    result.tangent = perspectiveCorrectInterpolate(t, start.tangent, end.tangent, startInvW, endInvW);
    result.bitangent = perspectiveCorrectInterpolate(t, start.bitangent, end.bitangent, startInvW, endInvW);
    return result;
}