xsl/Vulkan-Samples
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

init

Browse Source
This commit is contained in:
xsl
2025-09-04 10:54:47 +08:00
commit 6bc8f61b18
1808 changed files with 208268 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
shaders/fragment_shading_rate_dynamic/generate_shading_rate.comp
+83
View File
@@ -0,0 +1,83 @@
#version 450
/* Copyright (c) 2020-2021, Holochip
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 the "License";
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
layout(local_size_x = 8, local_size_y = 8) in;
layout(binding = 0, rg8ui) uniform readonly uimage2D input_frequency;
layout(binding = 1, r8ui) uniform writeonly uimage2D output_sampling_rate;
layout(binding = 2) buffer FrequencyInformation
{
uvec4 settings; // {frame_width, frame_height, output_width, output_height}
uvec4 frequency_information; // { max_rate_x, max_rate_y, n_rates, ...}
uvec2 rates[];
}
params;
void main()
{
const uint x0 = gl_GlobalInvocationID.x,
y0 = gl_GlobalInvocationID.y,
frame_width = params.settings[0],
frame_height = params.settings[1],
output_width = params.settings[2],
output_height = params.settings[3];
const uint delta_x = max(1, uint(round(float(frame_width) / float(output_width)))),
delta_y = max(1, uint(round(float(frame_height) / float(output_height))));
if (x0 >= output_width || y0 >= output_height)
{
return;
}
vec2 max_freqs = vec2(0, 0);
for (uint i = 0; i < delta_x; ++i)
{
for (uint j = 0; j < delta_y; ++j)
{
ivec2 coord = ivec2(delta_x * x0 + i, delta_y * y0 + j);
vec2 freq = vec2(imageLoad(input_frequency, coord)) / 255.f;
max_freqs = max(max_freqs, freq);
}
}
vec2 freqs = min(1.25 * sqrt(max_freqs), vec2(1, 1));
const float min_rate = 1,
max_rate = max(params.frequency_information.x, params.frequency_information.y);
const vec2 optimal_rate = freqs * vec2(min_rate, min_rate) + (1 - freqs) * vec2(max_rate, max_rate); //round(frequency * min_rate + (1 - frequency) * max_rate);
const uint n_rates = params.frequency_information.z;
uint optimal_rate_index = 0;
float current_cost = 1 + 2 * max_rate * max_rate;
for (uint i = 0; i < n_rates; ++i)
{
uvec2 rate = params.rates[i];
float cost = (rate.x - optimal_rate.x) * (rate.x - optimal_rate.x) + (rate.y - optimal_rate.y) * (rate.y - optimal_rate.y);
if (cost < current_cost)
{
current_cost = cost;
optimal_rate_index = i;
}
}
uint optimal_rate_x = params.rates[optimal_rate_index].x, optimal_rate_y = params.rates[optimal_rate_index].y;
uint rate_code = uint(optimal_rate_y >> 1) | ((optimal_rate_x << 1) & 12);
imageStore(output_sampling_rate, ivec2(x0, y0), uvec4(rate_code));
}
shaders/fragment_shading_rate_dynamic/scene.frag
+124
View File
@@ -0,0 +1,124 @@
#version 450
/* Copyright (c) 2020-2021, Holochip
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 the "License";
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#extension GL_EXT_fragment_shading_rate : require
layout(binding = 1) uniform sampler2D samplerEnvMap;
layout(binding = 2) uniform sampler2D samplerSphere;
layout(binding = 3, rg8ui) uniform readonly uimage2D input_frequency;
layout(binding = 4, r8ui) uniform readonly uimage2D output_sampling_rate;
layout(location = 0) in vec2 inUV;
layout(location = 1) in vec3 inPos;
layout(location = 2) in vec3 inNormal;
layout(location = 3) in vec3 inViewVec;
layout(location = 4) in vec3 inLightVec;
layout(binding = 0) uniform UBO
{
mat4 projection;
mat4 modelview;
mat4 skybox_modelview;
int color_shading_rates;
}
ubo;
layout(location = 0) out vec4 outColor;
layout(location = 1) out uvec2 outFrequency;
layout(push_constant) uniform Push_Constants
{
vec4 offset;
int object_type;
}
push_constants;
void main()
{
vec4 color;
float freq_x = 0, freq_y = 0;
switch (push_constants.object_type)
{
case 0: // Skysphere
{
color = texture(samplerEnvMap, vec2(inUV.s, 1.0 - inUV.t));
vec3 dx = dFdx(color.xyz);
vec3 dy = dFdx(color.xyz);
freq_x = dot(dx, dx);
freq_y = dot(dy, dy);
}
break;
case 1: // Phong shading
{
vec4 tex_value = texture(samplerSphere, vec2(inUV.s, 1.0 - inUV.t));
vec3 ambient = tex_value.rgb;
vec3 N = normalize(inNormal);
vec3 L = normalize(inLightVec);
vec3 V = normalize(inViewVec);
vec3 R = reflect(-L, N);
vec3 diffuse = vec3(max(dot(N, L), 0.0));
vec3 specular = vec3(pow(max(dot(R, V), 0.0), 8.0));
color = vec4(ambient + diffuse + specular, 1.0);
vec3 dx = dFdx(color.xyz);
vec3 dy = dFdy(color.xyz);
freq_x = dot(dx, dx);
freq_y = dot(dy, dy);
}
break;
}
if (ubo.color_shading_rates == 1)
{
// Visualize fragment shading rates
int v = 1;
int h = 1;
if ((gl_ShadingRateEXT & gl_ShadingRateFlag2VerticalPixelsEXT) == gl_ShadingRateFlag2VerticalPixelsEXT)
{
v = 2;
}
if ((gl_ShadingRateEXT & gl_ShadingRateFlag4VerticalPixelsEXT) == gl_ShadingRateFlag4VerticalPixelsEXT)
{
v = 4;
}
if ((gl_ShadingRateEXT & gl_ShadingRateFlag2HorizontalPixelsEXT) == gl_ShadingRateFlag2HorizontalPixelsEXT)
{
h = 2;
}
if ((gl_ShadingRateEXT & gl_ShadingRateFlag4HorizontalPixelsEXT) == gl_ShadingRateFlag4HorizontalPixelsEXT)
{
h = 4;
}
outColor = vec4(vec3(1, 1, 1) * (1 - h * v / 16.0), 1);
}
else if (ubo.color_shading_rates == 2)
{
ivec2 coord = ivec2(gl_FragCoord);
outColor = imageLoad(input_frequency, coord);
}
else
{
outColor = vec4(color.rgb, 1.0);
}
outFrequency = uvec2(255 * freq_x, 255 * freq_y);
}
shaders/fragment_shading_rate_dynamic/scene.vert
+64
View File
@@ -0,0 +1,64 @@
#version 450
/* Copyright (c) 2020-2021, Holochip
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 the "License";
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
layout(location = 0) in vec3 inPos;
layout(location = 1) in vec3 inNormal;
layout(location = 2) in vec2 inUV;
layout(binding = 0) uniform UBO
{
mat4 projection;
mat4 modelview;
mat4 skybox_modelview;
int color_shading_rates;
}
ubo;
layout(location = 0) out vec2 outUV;
layout(location = 1) out vec3 outPos;
layout(location = 2) out vec3 outNormal;
layout(location = 3) out vec3 outViewVec;
layout(location = 4) out vec3 outLightVec;
layout(push_constant) uniform Push_Constants
{
vec4 offset;
int object_type;
}
push_constants;
void main()
{
switch (push_constants.object_type)
{
case 0: // Skysphere
outPos = vec3(mat3(ubo.skybox_modelview) * inPos);
gl_Position = vec4(ubo.projection * vec4(outPos, 1.0));
break;
case 1: // Object
vec3 localPos = inPos + push_constants.offset.xyz;
outPos = vec3(ubo.modelview * vec4(localPos, 1.0));
gl_Position = ubo.projection * ubo.modelview * vec4(localPos, 1.0);
break;
}
outUV = inUV;
outNormal = mat3(ubo.modelview) * inNormal;
vec3 lightPos = mat3(ubo.modelview) * vec3(0.0, -10.0, -10.0);
outLightVec = lightPos.xyz - outPos.xyz;
outViewVec = -outPos.xyz;
}