world aligned material implementation?

[Stranget0]

Hello folks!
As in title - I want my textures to be aligned to world space, with similar effect to this https://www.youtube.com/watch?v=JW8LfB5Gkm0&t=309s
My vertex and fragment shaders come from bevy.

Im experimenting with using world_position that is created using mesh_functions::mesh_position_local_to_world from this bevy wgsl file that is also used in the (I suppose) default implementation of vertex shader for StandardMaterial

For now I'm trying to simply map xy world coordinates to uv, for now without that good results

out.uv = out.world_position.xy * 0.1;

Here there are no visible artifacts around texture edges, but obviously the uv won't tile as I'd like
https://github.com/bevyengine/bevy/assets/22750053/4187bfca-659e-4b19-b5f9-f6eec7e75fc4

out.uv = fract(out.world_position.xy * 0.1);

The texture is tiling, but I get weird artifacts around texture edges that seem to be influenced by vertexes

App-2024-04-11-22-50-30.mp4

whole shader code

#import bevy_pbr::pbr_fragment::pbr_input_from_standard_material;
#import bevy_pbr::pbr_functions::alpha_discard;


#ifdef PREPASS_PIPELINE
#import bevy_pbr::{
    prepass_io::{VertexOutput, FragmentOutput,},
    pbr_deferred_functions::deferred_output,
}
#else
#import bevy_pbr::forward_io::{Vertex, VertexOutput, FragmentOutput};
#import bevy_pbr::pbr_functions::{apply_pbr_lighting, main_pass_post_lighting_processing};
#endif

#import bevy_pbr::mesh_view_bindings::globals;

#import bevy_pbr::mesh_functions;
#import bevy_pbr::skinning;
#import bevy_pbr::morph::morph;
#import bevy_pbr::view_transformations::position_world_to_clip;


#ifdef MORPH_TARGETS
fn morph_vertex(vertex_in: Vertex) -> Vertex {
    var vertex = vertex_in;
    let weight_count = bevy_pbr::morph::layer_count();
    for (var i: u32 = 0u; i < weight_count; i ++) {
        let weight = bevy_pbr::morph::weight_at(i);
        if weight == 0.0 {
            continue;
        }
        vertex.position += weight * morph(vertex.index, bevy_pbr::morph::position_offset, i);
#ifdef VERTEX_NORMALS
        vertex.normal += weight * morph(vertex.index, bevy_pbr::morph::normal_offset, i);
#endif
#ifdef VERTEX_TANGENTS
        vertex.tangent += vec4(weight * morph(vertex.index, bevy_pbr::morph::tangent_offset, i), 0.0);
#endif
    }
    return vertex;
}
#endif

@vertex
fn vertex(vertex_no_morph: Vertex) -> VertexOutput {
    var out: VertexOutput;

#ifdef MORPH_TARGETS
    var vertex = morph_vertex(vertex_no_morph);
#else
    var vertex = vertex_no_morph;
#endif

#ifdef SKINNED
    var model = skinning::skin_model(vertex.joint_indices, vertex.joint_weights);
#else
    // Use vertex_no_morph.instance_index instead of vertex.instance_index to work around a wgpu dx12 bug.
    // See https://github.com/gfx-rs/naga/issues/2416 .
    var model = mesh_functions::get_model_matrix(vertex_no_morph.instance_index);
#endif

#ifdef VERTEX_NORMALS
#ifdef SKINNED
    out.world_normal = skinning::skin_normals(model, vertex.normal);
#else
    out.world_normal = mesh_functions::mesh_normal_local_to_world(
        vertex.normal,
        // Use vertex_no_morph.instance_index instead of vertex.instance_index to work around a wgpu dx12 bug.
        // See https://github.com/gfx-rs/naga/issues/2416
        vertex_no_morph.instance_index
    );
#endif
#endif

#ifdef VERTEX_POSITIONS
    out.world_position = mesh_functions::mesh_position_local_to_world(model, vec4<f32>(vertex.position, 1.0));
    out.position = position_world_to_clip(out.world_position.xyz);
#endif

#ifdef VERTEX_UVS
    out.uv = fract(out.world_position.xy * 0.1);
#endif

#ifdef VERTEX_UVS_B
    out.uv_b = fract(out.world_position.xy * 0.1);
#endif

#ifdef VERTEX_TANGENTS
    out.world_tangent = mesh_functions::mesh_tangent_local_to_world(
        model,
        vertex.tangent,
        // Use vertex_no_morph.instance_index instead of vertex.instance_index to work around a wgpu dx12 bug.
        // See https://github.com/gfx-rs/naga/issues/2416
        vertex_no_morph.instance_index
    );
#endif

#ifdef VERTEX_COLORS
    out.color = vertex.color;
#endif

#ifdef VERTEX_OUTPUT_INSTANCE_INDEX
    // Use vertex_no_morph.instance_index instead of vertex.instance_index to work around a wgpu dx12 bug.
    // See https://github.com/gfx-rs/naga/issues/2416
    out.instance_index = vertex_no_morph.instance_index;
#endif

    return out;
}

@fragment
fn fragment(
    in: VertexOutput,
    @builtin(front_facing) is_front: bool,
) -> FragmentOutput {
    // generate a PbrInput struct from the StandardMaterial bindings
    var pbr_input = pbr_input_from_standard_material(in, is_front);

    // we can optionally modify the input before lighting and alpha_discard is applied
    // pbr_input.material.base_color.b = pbr_input.material.base_color.r;
		// pbr_input.material.base_color.r = in.uv.x;
		// pbr_input.material.base_color.g = in.uv.y;
		// pbr_input.material.base_color.b = 0.0;

    // alpha discard
    pbr_input.material.base_color = alpha_discard(pbr_input.material, pbr_input.material.base_color);

#ifdef PREPASS_PIPELINE
    // in deferred mode we can't modify anything after that, as lighting is run in a separate fullscreen shader.
    let out = deferred_output(in, pbr_input);
#else
    var out: FragmentOutput;
    // apply lighting
		out.color = apply_pbr_lighting(pbr_input);



    out.color = main_pass_post_lighting_processing(pbr_input, out.color);

    // we can optionally modify the final result here
    // out.color = out.color * 2.0;
#endif

    return out;
}

[Stranget0]

Ok, I got some fine results by making this fragment shader here, instead of modifying vertex shader:

#import bevy_pbr::pbr_fragment::pbr_input_from_standard_material;
#import bevy_pbr::pbr_functions::alpha_discard;


#ifdef PREPASS_PIPELINE
#import bevy_pbr::{
    prepass_io::{VertexOutput, FragmentOutput,},
    pbr_deferred_functions::deferred_output,
}
#else
#import bevy_pbr::forward_io::{Vertex, VertexOutput, FragmentOutput};
#import bevy_pbr::pbr_functions::{apply_pbr_lighting, main_pass_post_lighting_processing};
#endif

#import bevy_pbr::mesh_view_bindings::globals;

#import bevy_pbr::pbr_bindings;
#import bevy_pbr::mesh_functions;
#import bevy_pbr::skinning;
#import bevy_pbr::morph::morph;
#import bevy_pbr::view_transformations::position_world_to_clip;


@fragment
fn fragment(
    in: VertexOutput,
    @builtin(front_facing) is_front: bool,
) -> FragmentOutput {
    // generate a PbrInput struct from the StandardMaterial bindings
    var pbr_input = pbr_input_from_standard_material(in, is_front);

    // we can optionally modify the input before lighting and alpha_discard is applied
		pbr_input.material.base_color = textureSample(pbr_bindings::base_color_texture, pbr_bindings::base_color_sampler, fract(in.world_position.xy * 0.1));
		
    // alpha discard
    pbr_input.material.base_color = alpha_discard(pbr_input.material, pbr_input.material.base_color);

#ifdef PREPASS_PIPELINE
    // in deferred mode we can't modify anything after that, as lighting is run in a separate fullscreen shader.
    let out = deferred_output(in, pbr_input);
#else
    var out: FragmentOutput;
    // apply lighting
    out.color = apply_pbr_lighting(pbr_input);

    out.color = main_pass_post_lighting_processing(pbr_input, out.color);

    // we can optionally modify the final result here
#endif

    return out;
}

The change is line
pbr_input.material.base_color = textureSample(pbr_bindings::base_color_texture, pbr_bindings::base_color_sampler, fract(in.world_position.xy * 0.1));

I believe I could make a ExtenderMaterial addon that has this feature when I get finished