This looks like an issue with normal map lighting but want to confirm before reporting as an issue

[coopergj]

`The orientation of the UV coordinates of a mesh relative to the light have a very strong impact on how that light is rendered on the mesh which really feels incorrect to me. In the attached screen capture, I have rendered the same normal texture 4 ways, left to right, they are:

• UV coordinates from left to right, back to front
• same but with the texture map image rotated
• UV coordinates from left to right, back to front but rotated 180 degrees using a transform
• UV coordinates from right to left, front to back

You will see that when the UV coordinates are rotated (the 2 on the right), it has a huge impact on the lighting which doesn't make sense and doesn't look correct given where the light is. Mesh 2 shows that rotating the texture map does not have a significant impact on lighting so why would rotating the UV coordinates have such an impact.

I get the same results in 0.13.1 and 0.14.2.

I would love to find out I am doing something wrong because trying to work around this in my application would be quite difficult.

The textures are here:

The code is below:
`mod utils;

use std::f32::consts::PI;
use wasm_bindgen::prelude::;
use bevy::prelude::;
use bevy::render::{
mesh::{Indices},
render_asset::RenderAssetUsages,
render_resource::PrimitiveTopology,
};
use bevy::window::{CursorGrabMode, PresentMode, PrimaryWindow};

#[cfg(feature = "wee_alloc")]
#[global_allocator]
static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;

#[wasm_bindgen]
extern {
fn alert(s: &str);
}

#[wasm_bindgen]
pub fn greet(width: f32, height:f32) {
build( width, height )
}

fn build(width: f32, height: f32) {
let y = App::new()
.add_plugins(DefaultPlugins.set(WindowPlugin {
primary_window: Some(Window{
title: "Bevy Example".into(),
resolution: (width, height).into(),
// canvas: Some("#BevyCanvas".into()),
present_mode: PresentMode::AutoVsync,
..default()
}),
..default()
}))
.add_systems( Startup, (setup))
.run();
}

/// set up a simple 3D scene
fn setup(
mut commands: Commands,
mut meshes: ResMut<Assets>,
mut materials: ResMut<Assets>,
asset_server: Res
) {
let materialWithNormal = materials.add(StandardMaterial {
base_color: Color::rgb(0.7, 0.7, 0.7),
normal_map_texture: Some(asset_server.load("Materials/TCom_Leather_Plain04_012x012_1K_normal.png")),
//normal_map_texture: Some(asset_server.load("Materials/TCom_FabricLinen_1K_normal.png")),
metallic: 0.0,
perceptual_roughness: 0.3,
unlit: false,
..default()
});

let materialRotated = materials.add(StandardMaterial {
    base_color: Color::rgb(0.7, 0.7, 0.7),
    normal_map_texture: Some(asset_server.load("Materials/TCom_Leather_Plain04_012x012_1K_normal_rotated.png")),
    metallic: 0.0,
    perceptual_roughness: 0.3,
    unlit: false,
    ..default()
});

let mesh = create_mesh(true, false);
let mesh_handle: Handle<Mesh> = meshes.add(mesh);
commands.spawn((PbrBundle {
    mesh: mesh_handle,
    material: materialWithNormal.clone(),
    transform: Transform::from_xyz(-2.0, 0.0, -0.0),
    ..default()
}));

let mesh = create_mesh(true, false );
let mesh_handle: Handle<Mesh> = meshes.add(mesh);
commands.spawn((PbrBundle {
    mesh: mesh_handle,
    material: materialRotated.clone(),
    transform: Transform::from_xyz(-1.0, 0.0, 0.0),
    ..default()
}));

let mesh = create_mesh(true, false);
let mesh_handle: Handle<Mesh> = meshes.add(mesh);
commands.spawn((PbrBundle {
    mesh: mesh_handle,
    material: materialWithNormal.clone(),
    transform: Transform {
        translation: Vec3::new(0.0, 0.0, 0.0),
        rotation: Quat::from_rotation_y(PI),
        ..default()
    },
    ..default()
}));

let mesh = create_mesh(true, true );
let mesh_handle: Handle<Mesh> = meshes.add(mesh);
commands.spawn((PbrBundle {
    mesh: mesh_handle,
    material: materialWithNormal.clone(),
    transform: Transform::from_xyz(1.0, 0.0, 0.0),
    ..default()
}));

let center_horizontal = -0.5;

// let mesh_handle: Handle<Mesh> = meshes.add(mesh);
// commands.spawn((PbrBundle {
//     mesh: mesh_handle,
//     material: materialWithNormal.clone(),
//     transform: Transform::from_xyz(1.0, 0.0, -2.0),
//     ..default()
// }));

commands.insert_resource(AmbientLight {
    color: Color::rgb(1.0, 1.0, 1.0).into(),
    brightness: 0.5,
});

// dining room  lights
let y = 2.0;
let x= center_horizontal;
let z = -1.5;
spawnLight(&mut commands, &mut meshes, &mut materials, x, y, z);
// let x= 1.5;
// let z = -0.5;
// spawnPotLight(&mut commands, &mut meshes, &mut materials, x, y, z);
// let x= 1.5;
// let z = -2.5;
// spawnPotLight(&mut commands, &mut meshes, &mut materials, x, y, z);

// camera
commands.spawn(Camera3dBundle {
    transform: Transform::from_xyz(center_horizontal, 2.0, 3.0).looking_at(
        Vec3::new(center_horizontal, 0.0, 0.0), Vec3::Y),
    //        Vec3::new(2.0,1.8,0.0), Vec3::Y),
    ..default()
})
;

}

fn get_uv(rotateUVFlag: bool) -> Vec<[f32;2]> {
match rotateUVFlag {
false => {
return vec![
[0.0, 0.0],
[1.0, 0.0],
[1.0, 1.0],
[0.0, 1.0],
];
}
true => {
return vec![
[1.0, 1.0],
[0.0, 1.0],
[0.0, 0.0],
[1.0, 0.0],
];
}
}
}

fn create_mesh(tangentFlag: bool, rotateUVFlag: bool) -> Mesh {
let coords: Vec<[f32;3]> = vec![
[-0.5, 0.0, 0.5],
[0.5, 0.0, 0.5],
[0.5, 0.0, -0.5],
[-0.5, 0.0, -0.5],
];
let normals : Vec<[f32;3]> = vec![
[0.0, 1.0, 0.0],
[0.0, 1.0, 0.0],
[0.0, 1.0, 0.0],
[0.0, 1.0, 0.0],
];
let uv = get_uv(rotateUVFlag);
let indices: Vec = vec![
0, 1, 2, 0, 2, 3
];
let rc1 = Mesh::new(PrimitiveTopology::TriangleList, RenderAssetUsages::MAIN_WORLD | RenderAssetUsages::RENDER_WORLD)
.with_inserted_attribute(
Mesh::ATTRIBUTE_POSITION,
// Each array is an [x, y, z] coordinate in local space.
// Meshes always rotate around their local [0, 0, 0] when a rotation is applied to their Transform.
// By centering our mesh around the origin, rotating the mesh preserves its center of mass.
coords,
)
.with_inserted_attribute(
Mesh::ATTRIBUTE_NORMAL,
normals,
)
// Note: (0.0, 0.0) = Top-Left in UV mapping, (1.0, 1.0) = Bottom-Right in UV mapping
.with_inserted_attribute(
Mesh::ATTRIBUTE_UV_0,
uv,
)

    .with_inserted_indices(Indices::U32(indices));
// return Some(rc1);
if( tangentFlag ) {
    let tangent_result = rc1.with_generated_tangents();
    match tangent_result {
        Ok(rc) => {
            return rc;
        }
        Err(error) => {
            panic!("Error in mesh: {:?}", error);
        }
    }
} else {
    return rc1
}

}

fn spawnLight(commands: &mut Commands, mut meshes: &mut ResMut<Assets>,
mut materials: &mut ResMut<Assets>, x: f32, y: f32, z: f32) {
commands.spawn( PointLightBundle {
point_light: PointLight {
intensity: 100000.0,
shadows_enabled: true,
color: Color::WHITE,
// inner_angle: PI / 3.0 * 0.85,
// outer_angle: PI / 2.0,
..default()
},
transform: Transform::from_xyz(x, y, z).looking_at(
Vec3::new(x, 0.0, z), Vec3::Z),
..default()
})
.with_children(|commands| {
// represent the light source as a sphere
let mesh = meshes.add(Sphere::new(0.05).mesh().ico(3).unwrap());
commands.spawn(PbrBundle { mesh, ..default() });
});

}

`

[ricky26]

Hi,

It looks like it's just down to non-normalised normal maps due to loading the normal maps as sRGB (which is the default).

You can fix it like so:

        normal_map_texture: Some(asset_server.load_with_settings(
            "Materials/TCom_Leather_Plain04_012x012_1K_normal.png",
            |s: &mut ImageLoaderSettings| s.is_srgb = false,
        )),

There's a doc issue for this #12123.

[coopergj]

Thank you very much RIcky for the response. This fixed it. That issue (which is not really an issue) didn't come up in my search so hopefully others will find that solution through this.