increase max num of lights
parent
6bb73bbe2d
commit
f101e735f6
|
|
@ -1,5 +1,7 @@
|
|||
use bevy::{input::system::exit_on_esc_system, pbr::AmbientLight, prelude::*};
|
||||
|
||||
mod rendering;
|
||||
|
||||
mod light_balls;
|
||||
use light_balls::*;
|
||||
mod player;
|
||||
|
|
@ -10,7 +12,7 @@ use columns::*;
|
|||
fn main() {
|
||||
App::build()
|
||||
.insert_resource(Msaa { samples: 4 })
|
||||
.add_plugins(DefaultPlugins)
|
||||
.add_plugins(rendering::CustomPlugins)
|
||||
.init_resource::<LightBallMaterials>()
|
||||
.add_startup_system(setup.system())
|
||||
.add_system(exit_on_esc_system.system())
|
||||
|
|
|
|||
|
|
@ -31,7 +31,7 @@ pub fn spawn_player(
|
|||
light_material.emissive = Color::rgb(15.0, 15.0, 15.0);
|
||||
let light_material = materials.add(light_material);
|
||||
|
||||
for i in 0..5 {
|
||||
for i in 0..10 {
|
||||
parent
|
||||
.spawn_bundle(PbrBundle {
|
||||
mesh: meshes.add(Mesh::from(shape::Icosphere {
|
||||
|
|
|
|||
|
|
@ -0,0 +1,102 @@
|
|||
use bevy::app::{PluginGroup, PluginGroupBuilder};
|
||||
use bevy::pbr::render_graph::{LightsNode, PBR_PIPELINE_HANDLE};
|
||||
use bevy::prelude::*;
|
||||
use bevy::render::{
|
||||
pipeline::PipelineDescriptor,
|
||||
render_graph::{base, AssetRenderResourcesNode, RenderGraph, RenderResourcesNode},
|
||||
shader::Shader,
|
||||
};
|
||||
|
||||
mod pipeline;
|
||||
use pipeline::build_pbr_pipeline;
|
||||
|
||||
pub struct CustomPlugins;
|
||||
impl PluginGroup for CustomPlugins {
|
||||
fn build(&mut self, group: &mut PluginGroupBuilder) {
|
||||
group.add(bevy::log::LogPlugin::default());
|
||||
group.add(bevy::core::CorePlugin::default());
|
||||
group.add(bevy::transform::TransformPlugin::default());
|
||||
group.add(bevy::diagnostic::DiagnosticsPlugin::default());
|
||||
group.add(bevy::input::InputPlugin::default());
|
||||
group.add(bevy::window::WindowPlugin::default());
|
||||
group.add(bevy::asset::AssetPlugin::default());
|
||||
group.add(bevy::scene::ScenePlugin::default());
|
||||
|
||||
group.add(bevy::render::RenderPlugin::default());
|
||||
group.add(bevy::sprite::SpritePlugin::default());
|
||||
group.add(CustomPbrPlugin::default());
|
||||
group.add(bevy::ui::UiPlugin::default());
|
||||
group.add(bevy::text::TextPlugin::default());
|
||||
group.add(bevy::gilrs::GilrsPlugin::default());
|
||||
group.add(bevy::gltf::GltfPlugin::default());
|
||||
group.add(bevy::winit::WinitPlugin::default());
|
||||
group.add(bevy::wgpu::WgpuPlugin::default());
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
pub struct CustomPbrPlugin;
|
||||
impl Plugin for CustomPbrPlugin {
|
||||
fn build(&self, app: &mut AppBuilder) {
|
||||
app.add_asset::<StandardMaterial>()
|
||||
.register_type::<Light>()
|
||||
.add_system_to_stage(
|
||||
CoreStage::PostUpdate,
|
||||
bevy::render::shader::asset_shader_defs_system::<StandardMaterial>.system(),
|
||||
)
|
||||
.init_resource::<bevy::pbr::AmbientLight>();
|
||||
add_pbr_graph(app.world_mut());
|
||||
|
||||
// add default StandardMaterial
|
||||
let mut materials = app
|
||||
.world_mut()
|
||||
.get_resource_mut::<Assets<StandardMaterial>>()
|
||||
.unwrap();
|
||||
materials.set_untracked(
|
||||
Handle::<StandardMaterial>::default(),
|
||||
StandardMaterial {
|
||||
base_color: Color::PINK,
|
||||
unlit: true,
|
||||
..Default::default()
|
||||
},
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// the names of pbr graph nodes
|
||||
mod node {
|
||||
pub const TRANSFORM: &str = "transform";
|
||||
pub const STANDARD_MATERIAL: &str = "standard_material";
|
||||
pub const LIGHTS: &str = "lights";
|
||||
}
|
||||
|
||||
fn add_pbr_graph(world: &mut World) {
|
||||
{
|
||||
let mut graph = world.get_resource_mut::<RenderGraph>().unwrap();
|
||||
graph.add_system_node(
|
||||
node::TRANSFORM,
|
||||
RenderResourcesNode::<GlobalTransform>::new(true),
|
||||
);
|
||||
graph.add_system_node(
|
||||
node::STANDARD_MATERIAL,
|
||||
AssetRenderResourcesNode::<StandardMaterial>::new(true),
|
||||
);
|
||||
graph.add_system_node(node::LIGHTS, LightsNode::new(30));
|
||||
|
||||
// TODO: replace these with "autowire" groups
|
||||
graph
|
||||
.add_node_edge(node::STANDARD_MATERIAL, base::node::MAIN_PASS)
|
||||
.unwrap();
|
||||
graph
|
||||
.add_node_edge(node::TRANSFORM, base::node::MAIN_PASS)
|
||||
.unwrap();
|
||||
graph
|
||||
.add_node_edge(node::LIGHTS, base::node::MAIN_PASS)
|
||||
.unwrap();
|
||||
}
|
||||
let pipeline = build_pbr_pipeline(&mut world.get_resource_mut::<Assets<Shader>>().unwrap());
|
||||
let mut pipelines = world
|
||||
.get_resource_mut::<Assets<PipelineDescriptor>>()
|
||||
.unwrap();
|
||||
pipelines.set_untracked(PBR_PIPELINE_HANDLE, pipeline);
|
||||
}
|
||||
|
|
@ -0,0 +1,392 @@
|
|||
// From the Filament design doc
|
||||
// https://google.github.io/filament/Filament.html#table_symbols
|
||||
// Symbol Definition
|
||||
// v View unit vector
|
||||
// l Incident light unit vector
|
||||
// n Surface normal unit vector
|
||||
// h Half unit vector between l and v
|
||||
// f BRDF
|
||||
// f_d Diffuse component of a BRDF
|
||||
// f_r Specular component of a BRDF
|
||||
// α Roughness, remapped from using input perceptualRoughness
|
||||
// σ Diffuse reflectance
|
||||
// Ω Spherical domain
|
||||
// f0 Reflectance at normal incidence
|
||||
// f90 Reflectance at grazing angle
|
||||
// χ+(a) Heaviside function (1 if a>0 and 0 otherwise)
|
||||
// nior Index of refraction (IOR) of an interface
|
||||
// ⟨n⋅l⟩ Dot product clamped to [0..1]
|
||||
// ⟨a⟩ Saturated value (clamped to [0..1])
|
||||
|
||||
// The Bidirectional Reflectance Distribution Function (BRDF) describes the surface response of a standard material
|
||||
// and consists of two components, the diffuse component (f_d) and the specular component (f_r):
|
||||
// f(v,l) = f_d(v,l) + f_r(v,l)
|
||||
//
|
||||
// The form of the microfacet model is the same for diffuse and specular
|
||||
// f_r(v,l) = f_d(v,l) = 1 / { |n⋅v||n⋅l| } ∫_Ω D(m,α) G(v,l,m) f_m(v,l,m) (v⋅m) (l⋅m) dm
|
||||
//
|
||||
// In which:
|
||||
// D, also called the Normal Distribution Function (NDF) models the distribution of the microfacets
|
||||
// G models the visibility (or occlusion or shadow-masking) of the microfacets
|
||||
// f_m is the microfacet BRDF and differs between specular and diffuse components
|
||||
//
|
||||
// The above integration needs to be approximated.
|
||||
|
||||
#version 450
|
||||
|
||||
const int MAX_LIGHTS = 10;
|
||||
|
||||
struct Light {
|
||||
mat4 proj;
|
||||
vec4 pos;
|
||||
vec4 color;
|
||||
};
|
||||
|
||||
layout(location = 0) in vec3 v_WorldPosition;
|
||||
layout(location = 1) in vec3 v_WorldNormal;
|
||||
layout(location = 2) in vec2 v_Uv;
|
||||
|
||||
#ifdef STANDARDMATERIAL_NORMAL_MAP
|
||||
layout(location = 3) in vec4 v_WorldTangent;
|
||||
#endif
|
||||
|
||||
layout(location = 0) out vec4 o_Target;
|
||||
|
||||
layout(set = 0, binding = 0) uniform CameraViewProj {
|
||||
mat4 ViewProj;
|
||||
};
|
||||
layout(std140, set = 0, binding = 1) uniform CameraPosition {
|
||||
vec4 CameraPos;
|
||||
};
|
||||
|
||||
layout(std140, set = 1, binding = 0) uniform Lights {
|
||||
vec4 AmbientColor;
|
||||
uvec4 NumLights;
|
||||
Light SceneLights[MAX_LIGHTS];
|
||||
};
|
||||
|
||||
layout(set = 3, binding = 0) uniform StandardMaterial_base_color {
|
||||
vec4 base_color;
|
||||
};
|
||||
|
||||
#ifdef STANDARDMATERIAL_BASE_COLOR_TEXTURE
|
||||
layout(set = 3, binding = 1) uniform texture2D StandardMaterial_base_color_texture;
|
||||
layout(set = 3,
|
||||
binding = 2) uniform sampler StandardMaterial_base_color_texture_sampler;
|
||||
#endif
|
||||
|
||||
#ifndef STANDARDMATERIAL_UNLIT
|
||||
|
||||
layout(set = 3, binding = 3) uniform StandardMaterial_roughness {
|
||||
float perceptual_roughness;
|
||||
};
|
||||
|
||||
layout(set = 3, binding = 4) uniform StandardMaterial_metallic {
|
||||
float metallic;
|
||||
};
|
||||
|
||||
# ifdef STANDARDMATERIAL_METALLIC_ROUGHNESS_TEXTURE
|
||||
layout(set = 3, binding = 5) uniform texture2D StandardMaterial_metallic_roughness_texture;
|
||||
layout(set = 3,
|
||||
binding = 6) uniform sampler StandardMaterial_metallic_roughness_texture_sampler;
|
||||
# endif
|
||||
|
||||
layout(set = 3, binding = 7) uniform StandardMaterial_reflectance {
|
||||
float reflectance;
|
||||
};
|
||||
|
||||
# ifdef STANDARDMATERIAL_NORMAL_MAP
|
||||
layout(set = 3, binding = 8) uniform texture2D StandardMaterial_normal_map;
|
||||
layout(set = 3,
|
||||
binding = 9) uniform sampler StandardMaterial_normal_map_sampler;
|
||||
# endif
|
||||
|
||||
# if defined(STANDARDMATERIAL_OCCLUSION_TEXTURE)
|
||||
layout(set = 3, binding = 10) uniform texture2D StandardMaterial_occlusion_texture;
|
||||
layout(set = 3,
|
||||
binding = 11) uniform sampler StandardMaterial_occlusion_texture_sampler;
|
||||
# endif
|
||||
|
||||
layout(set = 3, binding = 12) uniform StandardMaterial_emissive {
|
||||
vec4 emissive;
|
||||
};
|
||||
|
||||
# if defined(STANDARDMATERIAL_EMISSIVE_TEXTURE)
|
||||
layout(set = 3, binding = 13) uniform texture2D StandardMaterial_emissive_texture;
|
||||
layout(set = 3,
|
||||
binding = 14) uniform sampler StandardMaterial_emissive_texture_sampler;
|
||||
# endif
|
||||
|
||||
# define saturate(x) clamp(x, 0.0, 1.0)
|
||||
const float PI = 3.141592653589793;
|
||||
|
||||
float pow5(float x) {
|
||||
float x2 = x * x;
|
||||
return x2 * x2 * x;
|
||||
}
|
||||
|
||||
// distanceAttenuation is simply the square falloff of light intensity
|
||||
// combined with a smooth attenuation at the edge of the light radius
|
||||
//
|
||||
// light radius is a non-physical construct for efficiency purposes,
|
||||
// because otherwise every light affects every fragment in the scene
|
||||
float getDistanceAttenuation(const vec3 posToLight, float inverseRadiusSquared) {
|
||||
float distanceSquare = dot(posToLight, posToLight);
|
||||
float factor = distanceSquare * inverseRadiusSquared;
|
||||
float smoothFactor = saturate(1.0 - factor * factor);
|
||||
float attenuation = smoothFactor * smoothFactor;
|
||||
return attenuation * 1.0 / max(distanceSquare, 1e-4);
|
||||
}
|
||||
|
||||
// Normal distribution function (specular D)
|
||||
// Based on https://google.github.io/filament/Filament.html#citation-walter07
|
||||
|
||||
// D_GGX(h,α) = α^2 / { π ((n⋅h)^2 (α2−1) + 1)^2 }
|
||||
|
||||
// Simple implementation, has precision problems when using fp16 instead of fp32
|
||||
// see https://google.github.io/filament/Filament.html#listing_speculardfp16
|
||||
float D_GGX(float roughness, float NoH, const vec3 h) {
|
||||
float oneMinusNoHSquared = 1.0 - NoH * NoH;
|
||||
float a = NoH * roughness;
|
||||
float k = roughness / (oneMinusNoHSquared + a * a);
|
||||
float d = k * k * (1.0 / PI);
|
||||
return d;
|
||||
}
|
||||
|
||||
// Visibility function (Specular G)
|
||||
// V(v,l,a) = G(v,l,α) / { 4 (n⋅v) (n⋅l) }
|
||||
// such that f_r becomes
|
||||
// f_r(v,l) = D(h,α) V(v,l,α) F(v,h,f0)
|
||||
// where
|
||||
// V(v,l,α) = 0.5 / { n⋅l sqrt((n⋅v)^2 (1−α2) + α2) + n⋅v sqrt((n⋅l)^2 (1−α2) + α2) }
|
||||
// Note the two sqrt's, that may be slow on mobile, see https://google.github.io/filament/Filament.html#listing_approximatedspecularv
|
||||
float V_SmithGGXCorrelated(float roughness, float NoV, float NoL) {
|
||||
float a2 = roughness * roughness;
|
||||
float lambdaV = NoL * sqrt((NoV - a2 * NoV) * NoV + a2);
|
||||
float lambdaL = NoV * sqrt((NoL - a2 * NoL) * NoL + a2);
|
||||
float v = 0.5 / (lambdaV + lambdaL);
|
||||
return v;
|
||||
}
|
||||
|
||||
// Fresnel function
|
||||
// see https://google.github.io/filament/Filament.html#citation-schlick94
|
||||
// F_Schlick(v,h,f_0,f_90) = f_0 + (f_90 − f_0) (1 − v⋅h)^5
|
||||
vec3 F_Schlick(const vec3 f0, float f90, float VoH) {
|
||||
// not using mix to keep the vec3 and float versions identical
|
||||
return f0 + (f90 - f0) * pow5(1.0 - VoH);
|
||||
}
|
||||
|
||||
float F_Schlick(float f0, float f90, float VoH) {
|
||||
// not using mix to keep the vec3 and float versions identical
|
||||
return f0 + (f90 - f0) * pow5(1.0 - VoH);
|
||||
}
|
||||
|
||||
vec3 fresnel(vec3 f0, float LoH) {
|
||||
// f_90 suitable for ambient occlusion
|
||||
// see https://google.github.io/filament/Filament.html#lighting/occlusion
|
||||
float f90 = saturate(dot(f0, vec3(50.0 * 0.33)));
|
||||
return F_Schlick(f0, f90, LoH);
|
||||
}
|
||||
|
||||
// Specular BRDF
|
||||
// https://google.github.io/filament/Filament.html#materialsystem/specularbrdf
|
||||
|
||||
// Cook-Torrance approximation of the microfacet model integration using Fresnel law F to model f_m
|
||||
// f_r(v,l) = { D(h,α) G(v,l,α) F(v,h,f0) } / { 4 (n⋅v) (n⋅l) }
|
||||
vec3 specular(vec3 f0, float roughness, const vec3 h, float NoV, float NoL,
|
||||
float NoH, float LoH) {
|
||||
float D = D_GGX(roughness, NoH, h);
|
||||
float V = V_SmithGGXCorrelated(roughness, NoV, NoL);
|
||||
vec3 F = fresnel(f0, LoH);
|
||||
|
||||
return (D * V) * F;
|
||||
}
|
||||
|
||||
// Diffuse BRDF
|
||||
// https://google.github.io/filament/Filament.html#materialsystem/diffusebrdf
|
||||
// fd(v,l) = σ/π * 1 / { |n⋅v||n⋅l| } ∫Ω D(m,α) G(v,l,m) (v⋅m) (l⋅m) dm
|
||||
|
||||
// simplest approximation
|
||||
// float Fd_Lambert() {
|
||||
// return 1.0 / PI;
|
||||
// }
|
||||
//
|
||||
// vec3 Fd = diffuseColor * Fd_Lambert();
|
||||
|
||||
// Disney approximation
|
||||
// See https://google.github.io/filament/Filament.html#citation-burley12
|
||||
// minimal quality difference
|
||||
float Fd_Burley(float roughness, float NoV, float NoL, float LoH) {
|
||||
float f90 = 0.5 + 2.0 * roughness * LoH * LoH;
|
||||
float lightScatter = F_Schlick(1.0, f90, NoL);
|
||||
float viewScatter = F_Schlick(1.0, f90, NoV);
|
||||
return lightScatter * viewScatter * (1.0 / PI);
|
||||
}
|
||||
|
||||
// From https://www.unrealengine.com/en-US/blog/physically-based-shading-on-mobile
|
||||
vec3 EnvBRDFApprox(vec3 f0, float perceptual_roughness, float NoV) {
|
||||
const vec4 c0 = { -1, -0.0275, -0.572, 0.022 };
|
||||
const vec4 c1 = { 1, 0.0425, 1.04, -0.04 };
|
||||
vec4 r = perceptual_roughness * c0 + c1;
|
||||
float a004 = min(r.x * r.x, exp2(-9.28 * NoV)) * r.x + r.y;
|
||||
vec2 AB = vec2(-1.04, 1.04) * a004 + r.zw;
|
||||
return f0 * AB.x + AB.y;
|
||||
}
|
||||
|
||||
float perceptualRoughnessToRoughness(float perceptualRoughness) {
|
||||
// clamp perceptual roughness to prevent precision problems
|
||||
// According to Filament design 0.089 is recommended for mobile
|
||||
// Filament uses 0.045 for non-mobile
|
||||
float clampedPerceptualRoughness = clamp(perceptualRoughness, 0.089, 1.0);
|
||||
return clampedPerceptualRoughness * clampedPerceptualRoughness;
|
||||
}
|
||||
|
||||
// from https://64.github.io/tonemapping/
|
||||
// reinhard on RGB oversaturates colors
|
||||
vec3 reinhard(vec3 color) {
|
||||
return color / (1.0 + color);
|
||||
}
|
||||
|
||||
vec3 reinhard_extended(vec3 color, float max_white) {
|
||||
vec3 numerator = color * (1.0f + (color / vec3(max_white * max_white)));
|
||||
return numerator / (1.0 + color);
|
||||
}
|
||||
|
||||
// luminance coefficients from Rec. 709.
|
||||
// https://en.wikipedia.org/wiki/Rec._709
|
||||
float luminance(vec3 v) {
|
||||
return dot(v, vec3(0.2126, 0.7152, 0.0722));
|
||||
}
|
||||
|
||||
vec3 change_luminance(vec3 c_in, float l_out) {
|
||||
float l_in = luminance(c_in);
|
||||
return c_in * (l_out / l_in);
|
||||
}
|
||||
|
||||
vec3 reinhard_luminance(vec3 color) {
|
||||
float l_old = luminance(color);
|
||||
float l_new = l_old / (1.0f + l_old);
|
||||
return change_luminance(color, l_new);
|
||||
}
|
||||
|
||||
vec3 reinhard_extended_luminance(vec3 color, float max_white_l) {
|
||||
float l_old = luminance(color);
|
||||
float numerator = l_old * (1.0f + (l_old / (max_white_l * max_white_l)));
|
||||
float l_new = numerator / (1.0f + l_old);
|
||||
return change_luminance(color, l_new);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
void main() {
|
||||
vec4 output_color = base_color;
|
||||
#ifdef STANDARDMATERIAL_BASE_COLOR_TEXTURE
|
||||
output_color *= texture(sampler2D(StandardMaterial_base_color_texture,
|
||||
StandardMaterial_base_color_texture_sampler),
|
||||
v_Uv);
|
||||
#endif
|
||||
|
||||
#ifndef STANDARDMATERIAL_UNLIT
|
||||
// calculate non-linear roughness from linear perceptualRoughness
|
||||
# ifdef STANDARDMATERIAL_METALLIC_ROUGHNESS_TEXTURE
|
||||
vec4 metallic_roughness = texture(sampler2D(StandardMaterial_metallic_roughness_texture, StandardMaterial_metallic_roughness_texture_sampler), v_Uv);
|
||||
// Sampling from GLTF standard channels for now
|
||||
float metallic = metallic * metallic_roughness.b;
|
||||
float perceptual_roughness = perceptual_roughness * metallic_roughness.g;
|
||||
# endif
|
||||
|
||||
float roughness = perceptualRoughnessToRoughness(perceptual_roughness);
|
||||
|
||||
vec3 N = normalize(v_WorldNormal);
|
||||
|
||||
# ifdef STANDARDMATERIAL_NORMAL_MAP
|
||||
vec3 T = normalize(v_WorldTangent.xyz);
|
||||
vec3 B = cross(N, T) * v_WorldTangent.w;
|
||||
# endif
|
||||
|
||||
# ifdef STANDARDMATERIAL_DOUBLE_SIDED
|
||||
N = gl_FrontFacing ? N : -N;
|
||||
# ifdef STANDARDMATERIAL_NORMAL_MAP
|
||||
T = gl_FrontFacing ? T : -T;
|
||||
B = gl_FrontFacing ? B : -B;
|
||||
# endif
|
||||
# endif
|
||||
|
||||
# ifdef STANDARDMATERIAL_NORMAL_MAP
|
||||
mat3 TBN = mat3(T, B, N);
|
||||
N = TBN * normalize(texture(sampler2D(StandardMaterial_normal_map, StandardMaterial_normal_map_sampler), v_Uv).rgb * 2.0 - 1.0);
|
||||
# endif
|
||||
|
||||
# ifdef STANDARDMATERIAL_OCCLUSION_TEXTURE
|
||||
float occlusion = texture(sampler2D(StandardMaterial_occlusion_texture, StandardMaterial_occlusion_texture_sampler), v_Uv).r;
|
||||
# else
|
||||
float occlusion = 1.0;
|
||||
# endif
|
||||
|
||||
# ifdef STANDARDMATERIAL_EMISSIVE_TEXTURE
|
||||
vec4 emissive = emissive;
|
||||
// TODO use .a for exposure compensation in HDR
|
||||
emissive.rgb *= texture(sampler2D(StandardMaterial_emissive_texture, StandardMaterial_emissive_texture_sampler), v_Uv).rgb;
|
||||
# endif
|
||||
|
||||
vec3 V = normalize(CameraPos.xyz - v_WorldPosition.xyz);
|
||||
// Neubelt and Pettineo 2013, "Crafting a Next-gen Material Pipeline for The Order: 1886"
|
||||
float NdotV = max(dot(N, V), 1e-4);
|
||||
|
||||
// Remapping [0,1] reflectance to F0
|
||||
// See https://google.github.io/filament/Filament.html#materialsystem/parameterization/remapping
|
||||
vec3 F0 = 0.16 * reflectance * reflectance * (1.0 - metallic) + output_color.rgb * metallic;
|
||||
|
||||
// Diffuse strength inversely related to metallicity
|
||||
vec3 diffuseColor = output_color.rgb * (1.0 - metallic);
|
||||
|
||||
// accumulate color
|
||||
vec3 light_accum = vec3(0.0);
|
||||
for (int i = 0; i < int(NumLights.x) && i < MAX_LIGHTS; ++i) {
|
||||
Light light = SceneLights[i];
|
||||
|
||||
vec3 lightDir = light.pos.xyz - v_WorldPosition.xyz;
|
||||
vec3 L = normalize(lightDir);
|
||||
|
||||
float rangeAttenuation =
|
||||
getDistanceAttenuation(lightDir, light.pos.w);
|
||||
|
||||
vec3 H = normalize(L + V);
|
||||
float NoL = saturate(dot(N, L));
|
||||
float NoH = saturate(dot(N, H));
|
||||
float LoH = saturate(dot(L, H));
|
||||
|
||||
vec3 specular = specular(F0, roughness, H, NdotV, NoL, NoH, LoH);
|
||||
vec3 diffuse = diffuseColor * Fd_Burley(roughness, NdotV, NoL, LoH);
|
||||
|
||||
// Lout = f(v,l) Φ / { 4 π d^2 }⟨n⋅l⟩
|
||||
// where
|
||||
// f(v,l) = (f_d(v,l) + f_r(v,l)) * light_color
|
||||
// Φ is light intensity
|
||||
|
||||
// our rangeAttentuation = 1 / d^2 multiplied with an attenuation factor for smoothing at the edge of the non-physical maximum light radius
|
||||
// It's not 100% clear where the 1/4π goes in the derivation, but we follow the filament shader and leave it out
|
||||
|
||||
// See https://google.github.io/filament/Filament.html#mjx-eqn-pointLightLuminanceEquation
|
||||
// TODO compensate for energy loss https://google.github.io/filament/Filament.html#materialsystem/improvingthebrdfs/energylossinspecularreflectance
|
||||
// light.color.rgb is premultiplied with light.intensity on the CPU
|
||||
light_accum +=
|
||||
((diffuse + specular) * light.color.rgb) * (rangeAttenuation * NoL);
|
||||
}
|
||||
|
||||
vec3 diffuse_ambient = EnvBRDFApprox(diffuseColor, 1.0, NdotV);
|
||||
vec3 specular_ambient = EnvBRDFApprox(F0, perceptual_roughness, NdotV);
|
||||
|
||||
output_color.rgb = light_accum;
|
||||
output_color.rgb += (diffuse_ambient + specular_ambient) * AmbientColor.xyz * occlusion;
|
||||
output_color.rgb += emissive.rgb * output_color.a;
|
||||
|
||||
// tone_mapping
|
||||
output_color.rgb = reinhard_luminance(output_color.rgb);
|
||||
// Gamma correction.
|
||||
// Not needed with sRGB buffer
|
||||
// output_color.rgb = pow(output_color.rgb, vec3(1.0 / 2.2));
|
||||
#endif
|
||||
|
||||
o_Target = output_color;
|
||||
}
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
#version 450
|
||||
|
||||
layout(location = 0) in vec3 Vertex_Position;
|
||||
layout(location = 1) in vec3 Vertex_Normal;
|
||||
layout(location = 2) in vec2 Vertex_Uv;
|
||||
|
||||
#ifdef STANDARDMATERIAL_NORMAL_MAP
|
||||
layout(location = 3) in vec4 Vertex_Tangent;
|
||||
#endif
|
||||
|
||||
layout(location = 0) out vec3 v_WorldPosition;
|
||||
layout(location = 1) out vec3 v_WorldNormal;
|
||||
layout(location = 2) out vec2 v_Uv;
|
||||
|
||||
layout(set = 0, binding = 0) uniform CameraViewProj {
|
||||
mat4 ViewProj;
|
||||
};
|
||||
|
||||
#ifdef STANDARDMATERIAL_NORMAL_MAP
|
||||
layout(location = 3) out vec4 v_WorldTangent;
|
||||
#endif
|
||||
|
||||
layout(set = 2, binding = 0) uniform Transform {
|
||||
mat4 Model;
|
||||
};
|
||||
|
||||
void main() {
|
||||
vec4 world_position = Model * vec4(Vertex_Position, 1.0);
|
||||
v_WorldPosition = world_position.xyz;
|
||||
v_WorldNormal = mat3(Model) * Vertex_Normal;
|
||||
v_Uv = Vertex_Uv;
|
||||
#ifdef STANDARDMATERIAL_NORMAL_MAP
|
||||
v_WorldTangent = vec4(mat3(Model) * Vertex_Tangent.xyz, Vertex_Tangent.w);
|
||||
#endif
|
||||
gl_Position = ViewProj * world_position;
|
||||
}
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
use bevy::asset::Assets;
|
||||
use bevy::render::{
|
||||
pipeline::{
|
||||
BlendFactor, BlendOperation, BlendState, ColorTargetState, ColorWrite, CompareFunction,
|
||||
DepthBiasState, DepthStencilState, PipelineDescriptor, StencilFaceState, StencilState,
|
||||
},
|
||||
shader::{Shader, ShaderStage, ShaderStages},
|
||||
texture::TextureFormat,
|
||||
};
|
||||
|
||||
// pub const PBR_PIPELINE_HANDLE: HandleUntyped =
|
||||
// HandleUntyped::weak_from_u64(PipelineDescriptor::TYPE_UUID, 13148362314012771389);
|
||||
|
||||
pub(crate) fn build_pbr_pipeline(shaders: &mut Assets<Shader>) -> PipelineDescriptor {
|
||||
PipelineDescriptor {
|
||||
depth_stencil: Some(DepthStencilState {
|
||||
format: TextureFormat::Depth32Float,
|
||||
depth_write_enabled: true,
|
||||
depth_compare: CompareFunction::Less,
|
||||
stencil: StencilState {
|
||||
front: StencilFaceState::IGNORE,
|
||||
back: StencilFaceState::IGNORE,
|
||||
read_mask: 0,
|
||||
write_mask: 0,
|
||||
},
|
||||
bias: DepthBiasState {
|
||||
constant: 0,
|
||||
slope_scale: 0.0,
|
||||
clamp: 0.0,
|
||||
},
|
||||
clamp_depth: false,
|
||||
}),
|
||||
color_target_states: vec![ColorTargetState {
|
||||
format: TextureFormat::default(),
|
||||
color_blend: BlendState {
|
||||
src_factor: BlendFactor::SrcAlpha,
|
||||
dst_factor: BlendFactor::OneMinusSrcAlpha,
|
||||
operation: BlendOperation::Add,
|
||||
},
|
||||
alpha_blend: BlendState {
|
||||
src_factor: BlendFactor::One,
|
||||
dst_factor: BlendFactor::One,
|
||||
operation: BlendOperation::Add,
|
||||
},
|
||||
write_mask: ColorWrite::ALL,
|
||||
}],
|
||||
..PipelineDescriptor::new(ShaderStages {
|
||||
vertex: shaders.add(Shader::from_glsl(
|
||||
ShaderStage::Vertex,
|
||||
include_str!("pbr.vert"),
|
||||
)),
|
||||
fragment: Some(shaders.add(Shader::from_glsl(
|
||||
ShaderStage::Fragment,
|
||||
include_str!("pbr.frag"),
|
||||
))),
|
||||
})
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue