Resources for building custom PBR shaders?

[diondokter]

Hi all!

Today I've dipped my toes into creating a custom WGSL shader for my project.
I got the shader doing what I need (the 'custom' part of the shader), but now I want to add all the normal PBR things like textures, shadows, lighting, etc.

I need to be able to change some of the verts based on some input and to select different textures in the fragment shader based on some other input.

I found that parts of the standard PBR shader have been made reusable. However, I haven't been able to quite figure out how it's all supposed to fit together.

Are there any resources or examples for this?

Things I run into:

• How do I make my material also contain the standard material properties that the PBR shader sections can pick up? (I think I figured this out, but it feels kinda hacky, so not sure it's the right solution)
• Are there parts of the vert shader that are reusable? Now I just copied the vert shader from an example and that's fine for now.
• How are you supposed to call the frag shader PBR functions? I found pbr_input and the pbr function, but if I use it, all I seem to get is the ambient light color. What do all the fields on pbr_input even mean?
• How do I make shader programming nice in VSCode? I got hot reloading to work which is very nice, but if I use the wgsl-analyzer only half of the things seem to work and pretty much all #import statements get errors (even though it compiles just fine). I think I saw that Bevy 0.11 had some shader import changes. Is that the cause?

As you might see from my questions, I'm far from a shader expert. I've made some shaders in Unity in the past that were based on its standard shader. That's as far as my experience goes.

Thanks!

[nicopap]

Currently, your best option is copying as-is the bevy PBR shader and edit it with your modifications.

Check out the following repository, it's a good starting point for this: https://github.com/DGriffin91/bevy_mod_standard_material/

[evroon]

I have also been looking for this. You don't need to copy the builtin PBR shader anymore, support has been implemented for overriding the standard material in #7820

See the example with its shader.

[stan4cb]

I have started, but I have not completed it properly. However, I believe you can still make use of some parts of it. Hopefully, it will be helpful.

I'm not sure that it works properly but looks good enough

ground.wgsl

#import bevy_pbr::pbr_functions as pbr_functions
#import bevy_pbr::pbr_bindings as pbr_bindings
#import bevy_pbr::pbr_types as pbr_types

#import bevy_core_pipeline::tonemapping as tonemapping

#import bevy_pbr::mesh_types MESH_FLAGS_SHADOW_RECEIVER_BIT

#import bevy_pbr::mesh_vertex_output MeshVertexOutput
#import bevy_pbr::mesh_view_bindings view

struct GroundMaterial {
    tile_scale: f32,

    color_1: vec4<f32>,
    color_2: vec4<f32>,
};

@group(1) @binding(0)
var<uniform> data: GroundMaterial;

@group(1) @binding(1)
var my_color_texture: texture_2d<f32>;
@group(1) @binding(2)
var my_color_sampler: sampler;

@fragment
fn fragment(
    in: MeshVertexOutput
) -> @location(0) vec4<f32> {
    var uv = in.uv;
    var texture_color = textureSample(my_color_texture, my_color_sampler, in.uv);

    let is_orthographic = false;

    var pbr_in = pbr_functions::pbr_input_new();

    pbr_in.flags = MESH_FLAGS_SHADOW_RECEIVER_BIT; // finding this line was painfull

    pbr_in.material.base_color = vec4(1.);
    pbr_in.material.emissive = vec4( 0., 0., 0., 1.);

    pbr_in.material.metallic = 0.0;
    pbr_in.material.perceptual_roughness = 0.045;
    pbr_in.material.reflectance = 0.5;

    pbr_in.frag_coord = in.position;
    pbr_in.world_position = in.world_position;
    pbr_in.world_normal = pbr_functions::prepare_world_normal(
        in.world_normal,
        (pbr_in.material.flags & pbr_types::STANDARD_MATERIAL_FLAGS_DOUBLE_SIDED_BIT) != 0u,
        true,//in.is_front,
    );

    pbr_in.N = pbr_functions::apply_normal_mapping(pbr_in.material.flags, pbr_in.world_normal, in.uv, view.mip_bias);
    pbr_in.V = pbr_functions::calculate_view(in.world_position, is_orthographic);

    var pbr_result = pbr_functions::pbr(pbr_in);

    pbr_result = tonemapping::tone_mapping(pbr_result, view.color_grading);

    return pbr_result * texture_color; // * your_color;
}

ground.rs

use bevy::{
	prelude::*,
	reflect::TypePath,
	reflect::TypeUuid,
	render::render_resource::{AsBindGroup, ShaderRef},
};

#[derive(TypePath, AsBindGroup, Clone, TypeUuid)]
#[uuid = "8014bf20-d959-11ed-afa1-0242ac120001"]
pub struct GroundMaterial {
	#[uniform(0)]
	pub tile_scale: f32,

	#[uniform(0)]
	pub color_1: Color,
	#[uniform(0)]
	pub color_2: Color,

    #[texture(1)]
    #[sampler(2)]
    pub texture: Option<Handle<Image>>,
}

impl Material for GroundMaterial {
	fn fragment_shader() -> ShaderRef {
		"shaders/ground.wgsl".into()
	}

	fn alpha_mode(&self) -> AlphaMode {
		AlphaMode::Blend
	}
}

[Goffen]

I think you can skip a lot of the setup using this to base your change of:

@fragment
fn fragment(
    in: VertexOutput,
    @builtin(front_facing) is_front: bool,
) -> FragmentOutput {
    var pbr_input = pbr_input_from_standard_material(in, is_front);

Im also really struggling with this. There is almost no documentation on it either