fly/fgdata
1
0
Fork 0
Code Activity

HDR: Add tree shaders

Browse source
This commit is contained in:
Fernando García Liñán 2023-04-23 23:11:51 +02:00
parent 4ab57b15c2
commit 631bc13e94
4 changed files with 349 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

79
Effects/tree.eff
View file

@ -1873,4 +1873,83 @@
</uniform>
</pass>
</technique>
<technique n="109">
<scheme>hdr-geometry</scheme>
<predicate>
<property>/sim/rendering/random-vegetation</property>
</predicate>
<pass>
<!-- Reverse floating point depth buffer -->
<depth>
<function>gequal</function>
<near>1.0</near>
<far>0.0</far>
</depth>
<stencil>
<function>always</function>
<value>10</value>
<pass>replace</pass>
</stencil>
<texture-unit>
<unit>0</unit>
<type>2d</type>
<image><use>texture[0]/image</use></image>
<filter>linear-mipmap-linear</filter>
<wrap-s>clamp</wrap-s>
<wrap-t>clamp</wrap-t>
</texture-unit>
<blend>0</blend>
<rendering-hint>opaque</rendering-hint>
<cull-face>off</cull-face>
<program>
<vertex-shader>Shaders/HDR/tree.vert</vertex-shader>
<vertex-shader>Shaders/HDR/noise.glsl</vertex-shader>
<fragment-shader>Shaders/HDR/tree.frag</fragment-shader>
<fragment-shader>Shaders/HDR/gbuffer_pack.glsl</fragment-shader>
<fragment-shader>Shaders/HDR/normal_encoding.glsl</fragment-shader>
<fragment-shader>Shaders/HDR/color.glsl</fragment-shader>
</program>
<uniform>
<name>color_tex</name>
<type>sampler-2d</type>
<value type="int">0</value>
</uniform>
<uniform>
<name>season</name>
<type>float</type>
<value><use>season</use></value>
</uniform>
<uniform>
<name>cseason</name>
<type>float</type>
<value><use>cseason</use></value>
</uniform>
<uniform>
<name>num_deciduous_trees</name>
<type>int</type>
<value><use>num_deciduous_trees</use></value>
</uniform>
<uniform>
<name>forest_effect_size</name>
<type>float</type>
<value><use>forest_effect_size</use></value>
</uniform>
<uniform>
<name>forest_effect_shape</name>
<type>float</type>
<value><use>forest_effect_shape</use></value>
</uniform>
<uniform>
<name>WindE</name>
<type>float</type>
<value><use>windE</use></value>
</uniform>
<uniform>
<name>WindN</name>
<type>float</type>
<value><use>windN</use></value>
</uniform>
</pass>
</technique>
</PropertyList>

161
Shaders/HDR/noise.glsl Normal file
View file

@ -0,0 +1,161 @@
/*
* This is a library of noise functions, taking a coordinate vector and
* a wavelength as input and returning a number [0:1] as output.
* - Noise2D() is 2d Perlin noise.
* - Noise3D() is 3d Perlin noise.
* - DotNoise2D() is sparse dot noise and takes a dot density parameter.
* - DropletNoise2D() is sparse dot noise modified to look like liquid and
* takes a dot density parameter.
* - VoronoiNoise2D() is a function mapping the terrain into random domains,
* based on Voronoi tiling of a regular grid distorted with xrand and yrand.
* - SlopeLines2D() computes a semi-random set of lines along the direction of
* steepest descent, allowing to simulate e.g. water erosion patterns.
* - Strata3D() computes a vertically stratified random pattern, appropriate
* e.g. for rock textures
*
* Thorsten Renk 2014
*/
#version 330 core
float rand_2d(vec2 co)
{
return fract(sin(dot(co.xy, vec2(12.9898,78.233))) * 43758.5453);
}
float rand_3d(vec3 co)
{
return fract(sin(dot(co.xyz, vec3(12.9898,78.233,144.7272))) * 43758.5453);
}
float cosine_interpolate(float a, float b, float x)
{
float ft = x * 3.1415927;
float f = (1.0 - cos(ft)) * 0.5;
return a * (1.0 - f) + b * f;
}
float simple_interpolate(float a, float b, float x)
{
return a + smoothstep(0.0, 1.0, x) * (b - a);
}
float interpolated_noise_2d(vec2 coord)
{
float x = coord.x;
float y = coord.y;
float integer_x = x - fract(x);
float fractional_x = x - integer_x;
float integer_y = y - fract(y);
float fractional_y = y - integer_y;
float v1 = rand_2d(vec2(integer_x, integer_y));
float v2 = rand_2d(vec2(integer_x + 1.0, integer_y));
float v3 = rand_2d(vec2(integer_x, integer_y + 1.0));
float v4 = rand_2d(vec2(integer_x + 1.0, integer_y + 1.0));
float i1 = simple_interpolate(v1, v2, fractional_x);
float i2 = simple_interpolate(v3, v4, fractional_x);
return simple_interpolate(i1, i2, fractional_y);
}
float interpolated_noise_3d(vec3 coord)
{
float x = coord.x;
float y = coord.y;
float z = coord.z;
float integer_x = x - fract(x);
float fractional_x = x - integer_x;
float integer_y = y - fract(y);
float fractional_y = y - integer_y;
float integer_z = z - fract(z);
float fractional_z = z - integer_z;
float v1 = rand_3d(vec3(integer_x, integer_y, integer_z));
float v2 = rand_3d(vec3(integer_x + 1.0, integer_y, integer_z));
float v3 = rand_3d(vec3(integer_x, integer_y + 1.0, integer_z));
float v4 = rand_3d(vec3(integer_x + 1.0, integer_y + 1.0, integer_z));
float v5 = rand_3d(vec3(integer_x, integer_y, integer_z + 1.0));
float v6 = rand_3d(vec3(integer_x + 1.0, integer_y, integer_z + 1.0));
float v7 = rand_3d(vec3(integer_x, integer_y + 1.0, integer_z + 1.0));
float v8 = rand_3d(vec3(integer_x + 1.0, integer_y + 1.0, integer_z + 1.0));
float i1 = simple_interpolate(v1, v5, fractional_z);
float i2 = simple_interpolate(v2, v6, fractional_z);
float i3 = simple_interpolate(v3, v7, fractional_z);
float i4 = simple_interpolate(v4, v8, fractional_z);
float ii1 = simple_interpolate(i1, i2, fractional_x);
float ii2 = simple_interpolate(i3, i4, fractional_x);
return simple_interpolate(ii1, ii2, fractional_y);
}
float noise_2d(vec2 coord, float wavelength)
{
return interpolated_noise_2d(coord / wavelength);
}
float noise_3d(vec3 coord, float wavelength)
{
return interpolated_noise_3d(coord / wavelength);
}
float voronoi_noise_2d(vec2 coord, float xrand, float yrand)
{
float x = coord.x;
float y = coord.y;
float integer_x = x - fract(x);
float fractional_x = x - integer_x;
float integer_y = y - fract(y);
float fractional_y = y - integer_y;
float val[4];
val[0] = rand_2d(vec2(integer_x, integer_y));
val[1] = rand_2d(vec2(integer_x+1.0, integer_y));
val[2] = rand_2d(vec2(integer_x, integer_y+1.0));
val[3] = rand_2d(vec2(integer_x+1.0, integer_y+1.0));
float xshift[4];
xshift[0] = xrand * (rand_2d(vec2(integer_x+0.5, integer_y)) - 0.5);
xshift[1] = xrand * (rand_2d(vec2(integer_x+1.5, integer_y)) -0.5);
xshift[2] = xrand * (rand_2d(vec2(integer_x+0.5, integer_y+1.0))-0.5);
xshift[3] = xrand * (rand_2d(vec2(integer_x+1.5, integer_y+1.0))-0.5);
float yshift[4];
yshift[0] = yrand * (rand_2d(vec2(integer_x, integer_y +0.5)) - 0.5);
yshift[1] = yrand * (rand_2d(vec2(integer_x+1.0, integer_y+0.5)) -0.5);
yshift[2] = yrand * (rand_2d(vec2(integer_x, integer_y+1.5))-0.5);
yshift[3] = yrand * (rand_2d(vec2(integer_x+1.5, integer_y+1.5))-0.5);
float dist[4];
dist[0] = sqrt((fractional_x + xshift[0]) * (fractional_x + xshift[0]) + (fractional_y + yshift[0]) * (fractional_y + yshift[0]));
dist[1] = sqrt((1.0 -fractional_x + xshift[1]) * (1.0-fractional_x+xshift[1]) + (fractional_y +yshift[1]) * (fractional_y+yshift[1]));
dist[2] = sqrt((fractional_x + xshift[2]) * (fractional_x + xshift[2]) + (1.0-fractional_y +yshift[2]) * (1.0-fractional_y + yshift[2]));
dist[3] = sqrt((1.0-fractional_x + xshift[3]) * (1.0-fractional_x + xshift[3]) + (1.0-fractional_y +yshift[3]) * (1.0-fractional_y + yshift[3]));
int i_min;
float dist_min = 100.0;
for (int i = 0; i < 4; ++i) {
if (dist[i] < dist_min) {
dist_min = dist[i];
i_min = i;
}
}
return val[i_min];
}
float voronoi_noise_2d(vec2 coord, float wavelength, float xrand, float yrand)
{
return voronoi_noise_2d(coord / wavelength, xrand, yrand);
}

36
Shaders/HDR/tree.frag Normal file
View file

@ -0,0 +1,36 @@
#version 330 core
in VS_OUT {
vec2 texcoord;
vec3 vertex_normal;
float autumn_flag;
} fs_in;
uniform sampler2D color_tex;
uniform float cseason;
// gbuffer_pack.glsl
void gbuffer_pack(vec3 normal, vec3 base_color, float metallic, float roughness,
float occlusion, vec3 emissive, uint mat_id);
// color.glsl
vec3 eotf_inverse_sRGB(vec3 srgb);
void main()
{
vec4 texel = texture(color_tex, fs_in.texcoord);
if (texel.a < 0.33)
discard;
// Seasonal color changes
if (cseason < 1.5 && fs_in.autumn_flag > 0.0) {
texel.r = min(1.0, (1.0 + 5.0 * cseason * fs_in.autumn_flag) * texel.r);
texel.b = max(0.0, (1.0 - 8.0 * cseason) * texel.b);
}
vec3 color = eotf_inverse_sRGB(texel.rgb);
vec3 N = normalize(fs_in.vertex_normal);
gbuffer_pack(N, color, 0.0, 1.0, 1.0, vec3(0.0), 3u);
}

73
Shaders/HDR/tree.vert Normal file
View file

@ -0,0 +1,73 @@
#version 330 core
layout(location = 0) in vec4 pos;
layout(location = 1) in vec3 normal;
layout(location = 2) in vec4 vertex_color;
layout(location = 3) in vec4 multitexcoord0;
layout(location = 12) in float fogcoord;
out VS_OUT {
vec2 texcoord;
vec3 vertex_normal;
float autumn_flag;
} vs_out;
uniform int num_deciduous_trees;
uniform float season;
uniform float forest_effect_size;
uniform float forest_effect_shape;
uniform float WindN;
uniform float WindE;
uniform float osg_SimulationTime;
uniform mat4 osg_ModelViewMatrix;
uniform mat4 osg_ModelViewProjectionMatrix;
// noise.glsl
float voronoi_noise_2d(vec2 coord, float wavelength, float xrand, float yrand);
void main()
{
float num_varieties = normal.z;
float tex_fract = floor(fract(multitexcoord0.x) * num_varieties) / num_varieties;
if (tex_fract < float(num_deciduous_trees) / float(num_varieties)) {
vs_out.autumn_flag = 0.5 + fract(vertex_color.x);
} else {
vs_out.autumn_flag = 0.0;
}
tex_fract += floor(multitexcoord0.x) / num_varieties;
// Determine the rotation for the tree. The Fog Coordinate provides rotation
// information to rotate one of the quands by 90 degrees. We then apply an
// additional position seed so that trees aren't all oriented N/S
float sr = sin(fogcoord + vertex_color.x);
float cr = cos(fogcoord + vertex_color.x);
vs_out.texcoord = vec2(tex_fract, multitexcoord0.y);
vs_out.texcoord.y = vs_out.texcoord.y + 0.5 * season;
// scaling
vec3 position = pos.xyz * normal.xxy;
// Rotation of the generic quad to specific one for the tree.
position.xy = vec2(dot(position.xy, vec2(cr, sr)), dot(position.xy, vec2(-sr, cr)));
// Shear by wind. Note that this only applies to the top vertices
float vertex_color_sum = vertex_color.x + vertex_color.y + vertex_color.z;
float wind_offset = position.z * (
sin(osg_SimulationTime * 1.8 + vertex_color_sum * 0.01) + 1.0) * 0.0025;
position.x = position.x + wind_offset * WindN;
position.y = position.y + wind_offset * WindE;
// Scale by random domains
float voronoi = 0.5 + 1.0 * voronoi_noise_2d(
vertex_color.xy, forest_effect_size, forest_effect_shape, forest_effect_shape);
position.xyz *= voronoi;
position = position + vertex_color.xyz;
gl_Position = osg_ModelViewProjectionMatrix * vec4(position, 1.0);
vec3 view_vector = (osg_ModelViewMatrix * vec4(position, 1.0)).xyz;
vs_out.vertex_normal = normalize(-view_vector);
}